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

superdesolator

48.sapply用于函数的进一步解释

当函数为f=function(x){return (x)}的时候，我们对于v=1:3都可以如下

sapply(v,f)

但是当我们的函数形如

f=function(x,y,z){return (x+y+z)}

我们的x，在固定的，y变动怎么办呢？

如下

y=1:3

sapply(y,f,x=1,z=2)

注意变得写在第一个，然后第二个是函数名，后面就是不动的参数的值，要注意你定义的f的参数名是什么，这里就得用那个参数名

superdesolator

49.关于R中的=和<-的区别

这里有位大牛解释的很详细清晰了，我就直接搬过来了

http://renkun.me/blog/r/2014/01/28/difference-between-assignment-operators-in-r.html

简单来说，涉及到的概念有=号赋值，<-赋值，函数参数=号传参，函数参数<-传参，以及最后的函数命名参数=号传参

superdesolator

50.激动人心的初步学习R包的创建方法

又是搬砖，文章已经介绍的很详细了，要说的是，R的版本要求高（R 3.0.0貌似不可以，R 3.0.2可以）

主要是devtools这个工具的问题，还有就是需要安装Rcpp这个包，剩下基本没什么问题了，不过check()那一步我没怎么看，如果check()不过我也不知道怎么办，或者作者也没具体介绍可能哪些check()不过的情况以及对应的解决方法

http://cos.name/2013/11/building-r-packages-easily/

PS:卸载一个包用remove.packages('',lib=)

superdesolator

51.R中一些计时函数初步

首先，介绍proc.time()

## Not run:<br />
## a way to time an R expression: system.time is preferred<br />
ptm <- proc.time()<br />
for (i in 1:50) mad(stats::runif(500))<br />
proc.time() - ptm</p>
<p>## End(Not run)<br />

这个搬来的例子很详细的说明了用法，我实验了下，这个proc的意思应该是R 进程，所以对应的(proc.time()-proc.time())[3]意思就是以当前进程运行的时间之差，从而达到计算中间表达式的时间，不知道对不对

其次是用sys.time()

解释是说这个函数调用了前一个函数，效果对比如下

<br />
 <- proc.time()<br />
R>for (i in 1:50) mad(stats::runif(500))<br />
R>proc.time() - ptm<br />
   user  system elapsed<br />
   0.05    0.01    0.06<br />
R>system.time(for(i in 1:50) mad(runif(500)))<br />
   user  system elapsed<br />
   0.02    0.00    0.02<br />

出现了不一致，我也不知道原因[s:11]

另外，Sys.time()是用来记录系统时间的，大家运行一下看下结果就懂了

superdesolator

52.读取大数据初步

问题来源是

http://cos.name/cn/topic/135156

以后我们都可能会遇到这种问题，这个帖子解释的蛮清楚的，肖大大的方法是scan+matrix

14楼的方法不知道是不是最好的，貌似文件名是中文会出错？

基本上比read.table高级啦

大家也可以用50介绍的计时的方法比较下

superdesolator

53.关于"重载运算符"

刚读到一个东西,感觉自己以前一直不知道,熟悉C++的同学应该感觉下面介绍的会很亲切

R>"%c%"=function(x,y){<br />
+ return(x*y)}<br />
R>3%c%4<br />
[1] 12<br />
R>

话不多说，只要把c改成任何你想要的都可以，%*%的定义貌似就是这么来的，至于是什么机制可以这样，我就不知道了，以后有机会研究或等高手解答[s:11]

dugucan

不错，没事看看！

superdesolator

54.关于环境的初步之初步

x=2<br />
y=3<br />
env=new.env()<br />
env$x=1<br />
x<br />
eval(expression(x))<br />
eval(expression(x),env=env)<br />
eval(expression(x+y),env=env)<br />

直接上代码，先给大家来个初步认识，后续。。。。。。。

luyaosss

谢谢！

superdesolator

55.关于R中操作文件的方法

主要是list.files和list.dirs这两个函数，大家可以?list.files，看下这两个函数的参数，我觉得这两个函数功能太强大了,甚至我个人觉得比目前我学到的Python中的一些函数要强大方便（我学了2个月PYTHON了，也可能是我学的还比较浅啦）

我觉得比较重要的一个是recursive,另一个是pattern吧

这能使得我们对一个目录，列出旗下的所有目录，目录中的目录，以及目录中的文件，递归下去。

Pattern的话可以结合正则表达式找，这两个功能整合在一块了还是很牛的！！

不过由于我还没深入，不知道能不能指定递归一层或两层目录之类的....[s:11]

一个很小的实战

superdesolator

回复第86楼的 superdesolator：更进一步

R>a=1:5<br />
R>"second<-" <- function(x, value) {<br />
+      x[2] <- value<br />
+      x<br />
+  }<br />
R>second(a)=3<br />
R>a<br />
[1] 1 3 3 4 5

这里有个好玩的地方就是，"second<-"表达出来就是second(a)=3,能体会么？类似想到 a[3]=4,应该就是定义了

"[<-"=function(x,value{}[s:11] 怎么样？还是很有趣吧

superdesolator

回复第91楼的 superdesolator：更具体的讨论见

superdesolator

56.ADR之R中数据结构之Vecctors

自此帖开始的一段帖子基本上都会是摘自Advanced R的内容,比较适合进阶的R user，本来想重新开个帖子来记录的，想想还是从一而忠吧[s:11]，更喜欢看原书的可以点这里

首先R有基本的5种数据结构：

atomic vector,list,matrix,data frame,array

最基本的数据结构是Vectors这个大类，其中分为atomic vector和list两个小类，主要区别就是其中的数据类型是不是一致，共同点就是都有3个主要的性质typeof(),length(),attributes()，我们平常用的最多的c() (combine的意思) 就是指atomic vector,list嘛大家就比较熟悉了，所以判断一个东西是不是vector,可以is.atomic(x)||is.list(x)，有人问为什么不is.vector(x)，这里涉及到比较深的原因，反正有些东西就是不知道会出错啊！

下面来仔细讲atomic vectors：

这个结构又有4种基本类型，logical,integer,double,character以及大家暂时不必理会的2种类型complex,raw

dbl_var <- c(1, 2.5, 4.5)<br />
# With the L suffix, you get an integer rather than a double<br />
int_var <- c(1L, 6L, 10L)<br />
# Use TRUE and FALSE (or T and F) to create logical vectors<br />
log_var <- c(TRUE, FALSE, T, F)<br />
chr_var <- c("these are", "some strings")

我们平常说的numericl类型,其实是说integer或double

具体看类型就是前面说的typeof()以及is.integer()，is.atomic(),is.numeric()的is.系列

int_var <- c(1L, 6L, 10L)<br />
typeof(int_var)<br />
#> [1] "integer"

所以到这里，相信很多人会明白到底什么是typeof()什么是class()（这个class是后面要说的attributes中的一种），我以前就是混，觉得type和class是一个意思吧，当然mode()又是什么（等以后弄清楚吧，这里提一下）？

对于length()没什么好说的，唯一注意的是

a=1<br />
length(a)<br />
[1] 1

也就是说这是一个长度为1的integer 类型的atomic vector,更需要提到的是NA,是长度为1的logical类型的atomic vector,与此同时还有NA_real_ (a double vector), NA_integer_ and NA_character_这些类型！！！

R>length(NA)<br />
[1] 1<br />
R>is.logical(NA)<br />
[1] TRUE<br />
R>is.atomic(NA)<br />
[1] TRUE<br />
R>is.character(NA_character_)<br />
[1] TRUE<br />
R>is.character(NA)<br />
[1] FALSE

对于atomic vector,也就是通常的c(),还有要注意的是强制转换的顺序： logical, integer, double and character,也就是说你的c()里的东西本来应该是同一类型的，结果你弄了不同类型，那就按上面的顺序转

R>c(1,TRUE,2.5,'a')<br />
[1] "1"    "TRUE" "2.5"  "a"

这就都变character了

还有个attributes先讲lists:

lists由于可以放任一类型，所以其实就没什么好说的了，要注意的是

c(list(1,2),c(3,4))<br />
list(list(1,2),c(3,4))

结果是不一样的，前者的c()会把c()中的东西变成list再和list合并起来，具体大家试验下

对于lists，typeof()的结果还是list，也有个把list变成atomic vector的方法就是unlist(),如果list本身放的

东西类型不同，那么变成c()的结果和前面介绍的c()中强制转换结果一样

lists被用来构造很多R中的复杂的数据结构，例如lm(),data.frames

mod <- lm(mpg ~ wt, data = mtcars)<br />
is.list(mod)<br />
#> [1] TRUE

list的length()也就没什么好说的了

好，下面来介绍attributes():

这是个复杂的概念，不适合新手读，所有的对象都可以有额外的属性，我们可以这样设置

y <- 1:10<br />
attr(y, "my_attribute") <- "This is a vector"<br />
attr(y, "my_attribute")<br />
#> [1] "This is a vector"<br />
str(attributes(y))

原话是： Attributes can be accessed individually with attr() or all at once (as a list) with attributes().

或者

structure(1:10, my_attribute = "This is a vector")

当我们改动一个vector的时候，这个属性就会丢失比如上面设置了y的属性，我们

attributes(y[1])<br />
#> NULL<br />
attributes(sum(y))<br />
#> NULL

这就引出了，3个不会丢失的attributes:

names,dimensions,class(s3) s3,s4是什么大家暂时不必关心，我也不懂。。。

引用方式是： names(x), class(x) and dim(x), 而不是 attr(x, "names"), attr(x, "class"), and attr(x, "dim").这三个东西也是会陆续的出现在下面要介绍的数据结构中。

PS：介绍比较复杂的东西，自己也觉得写的比较乱。。。大家就这样看吧[s:11]

superdesolator

57.因子Factors

PS：这是一个系列贴，所以可能一个贴是以前面的贴为基础的

因子是attributes的一个重要应用！！它的本质其实就是

一个integer类型的atomic vector 然后加上两个attributes,一个是class(),"factor",一个是levels(),前一个决定了它的行为不同于普通的integer atomic vector (后面简称iac了），后一个决定了它允许的取值范围

<br />
R>a=factor(letters)<br />
R>typeof(a)<br />
[1] "integer"<br />
R>attributes(a)<br />
$levels<br />
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"<br />
[11] "k" "l" "m" "n" "o" "p" "q" "r" "s" "t"<br />
[21] "u" "v" "w" "x" "y" "z"</p>
<p>$class<br />
[1] "factor"</p>
<p>R>attr(a,"levels")<br />
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"<br />
[11] "k" "l" "m" "n" "o" "p" "q" "r" "s" "t"<br />
[21] "u" "v" "w" "x" "y" "z"<br />

很多时候，我们读数据

z <- read.csv(text="value\n12\n1\n.\n9")<br />
typeof(z$value)<br />
#> [1] "integer"<br />
as.double(z$value)<br />
#> [1] 3 2 1 4<br />
# Oops, that's not right: 3 2 1 4 are the levels of a factor,<br />
# not the values we read in!<br />
class(z$value)<br />
#> [1] "factor"<br />
# We can fix it now:<br />
as.double(as.character(z$value))<br />
#> Warning: NAs introduced by coercion<br />
#> [1] 12  1 NA  9<br />
# Or change how we read it in:

这是因为一旦有1列出现了missing value,比如.整个列就变成了factor,从factor到double,结果显然就会错

避免的办法是

z <- read.csv(text="value\n12\n1\n.\n9", na.strings=".")

或者

stringsAsFactors = FALSE 放进去，相信大家多少用过，原因就在这里了

superdesolator

58.矩阵，数组，数据框

这些东西大家应该都比较熟悉了，通过dim()去构造大家也应该不陌生，这里就不说了，对于arrays，这里面学问比较大，毕竟是高维的东西，好像有些专门的针对arrays的包，我暂时用不到高维的东西，2维的矩阵和数据框，一般常用，这里列出一些代码：

<br />
df <- data.frame(<br />
  x = 1:3,<br />
  y = c("a", "b", "c"),<br />
  stringsAsFactors = FALSE)<br />
str(df)<br />
#> 'data.frame':    3 obs. of  2 variables:<br />
#>  $ x: int  1 2 3<br />
#>  $ y: chr  "a" "b" "c"<br />
typeof(df)<br />
#> [1] "list"<br />
class(df)<br />
#> [1] "data.frame"<br />

这些事实前面介绍过，这里只是再回忆下。

这里最后要提下这个东西：

data.frame(x = 1:3, y = list(1:2, 1:3, 1:4))<br />
#> Error: arguments imply differing number of rows: 2, 3, 4<br />
dfl <- data.frame(x = 1:3, y = I(list(1:2, 1:3, 1:4)))<br />
df1<br />
#>   x          y<br />
#> 1 1       1, 2<br />
#> 2 2    1, 2, 3<br />
#> 3 3 1, 2, 3, 4<br />

或者

df <- data.frame(x = 1:3)<br />
df$y <- list(1:2, 1:3, 1:4)<br />
df<br />
#>   x          y<br />
#> 1 1       1, 2<br />
#> 2 2    1, 2, 3<br />
#> 3 3 1, 2, 3, 4

说实话，我还暂时没用到过这个形式[s:11]

superdesolator

59.子集Subsetting operator [

先来个下马威：

1.Why does x <- 1:5; x[NA] yield five missing values? Hint: why is it different from x[NA_real_]?

2.What does df[is.na(df)] <- 0 do? How does it work? How about df[!is.na(df)]<-0? Why? How to make it work?

df <- data.frame(x = 1:3, y = 3:1, z = letters[1:3])

是的，没那么简单：

[这个东西，再熟悉不过了，对于ac,l,m,a,df(数据结构的简写，不知道的话复习56）

但里面内容其实挺多，ADR也介绍了挺多，但对于非新手R玩家应该不是很难，对于向量有按位置取，按logical取，按names取

x <- c(2.1, 4.2, 3.3, 5.4)<br />
x[c(3, 1)]<br />
#> [1] 3.3 2.1<br />
x[c(TRUE, TRUE, FALSE, FALSE)]<br />
#> [1] 2.1 4.2<br />
x[c(TRUE, FALSE)]<br />
x[c(TRUE, FALSE, TRUE, FALSE)]<br />
#> [1] 2.1 3.3<br />
#> [1] 2.1 3.3<br />
x[c(TRUE, TRUE, NA, FALSE)]  #特别注意和赋值结合的时候x[c(TRUE, TRUE, NA, FALSE)] =0，NA会被测试为假<br />
#> [1] 2.1 4.2  NA<br />
(y <- setNames(x, letters[1:4]))<br />
#>   a   b   c   d<br />
#> 2.1 4.2 3.3 5.4<br />
y[c("d", "c", "a")]<br />
#>   d   c   a<br />
#> 5.4 3.3 2.1<br />

OK ，好了，第1题答案就在里面了，原因前面56-58的帖子中介绍过NA,他是一个长度为1的logical ac,然后用logical取子集的时候会自动扩张到原向量长度，而NA取子集是NA，所以会有5个NA，而对于NA_real_它不是个logical是个位置，所以只有1个NA！！怎么样？还是挺复杂又简单的吧？你读懂了没有？[s:11]

对于lists,matrices,arrays的[操作也没什么好说的，比如矩阵可以按向量的取法（矩阵在R中是列优先存储），按

矩阵的取法（同时给2个[x,y]或直接传入一个矩阵）这些就不细说了，因为这个系列贴面向有基础的R玩家

对于data.frame稍微提下这个：

df <- data.frame(x = 1:3, y = 3:1, z = letters[1:3])<br />
str(df["x"])<br />
#> 'data.frame':    3 obs. of  1 variable:<br />
#>  $ x: int  1 2 3<br />
str(df[, "x"])<br />
#>  int [1:3] 1 2 3<br />

这里展示了2种df取列的方式，显然本质还是不同的

OK，说到这里，第2题可能还是不会，其实首先它是个按logical的取子集的方式， df[is.na(df)] <- 0 这个工作正常，因为全是FALSE，我在原题上变了一下， df[!is.na(df)] <- 0 ,结果出问题了，因为全是TRUE了要设置了，而这里居然设置失败了！！为什么呢？

其实就是前面中说的Factors的原因，a,b,c是levels,而0不在levels中，因子就不能设置为0,所以得

<br />
df <- data.frame(x = 1:3, y = 3:1, z = letters[1:3],stringsAsFactors=F)<br />

这样就OK了

superdesolator

60.子集Subsetting operator [[

对于[[，最先接触的是list[[]]，大家都很熟悉，但这里我要介绍一个概念

Simplifying vs. preserving subsetting

大概意思就是简化与保留，说的是是否保留了原来的数据结构类型。

<br />
	Simplifying	       Preserving<br />
Vector	x[[1]]	                 x[1]<br />
List	x[[1]]	                  x[1]<br />
Factor	x[1:4, drop = T]	 x[1:4]<br />
Array	x[1, ] or x[, 1]	 x[1, , drop = F] or x[, 1, drop = F]<br />
Data frame x[, 1] or x[[1]]	 x[, 1, drop = F] or x[1]<br />

这里我就直接复制了表格，初一看吓一跳，vector居然也有[[操作,一个个解释很麻烦，我直接上每个例子的代码：

x <- c(a = 1, b = 2)<br />
x[1]<br />
#> a<br />
#> 1<br />
x[[1]]<br />
#> [1] 1

对于ac,一个去掉了name 简化了，一个没有，保留了，概念就这么简单！

所以，对于其他的结构：

z <- factor(c("a", "b")) #Factor<br />
z[1]<br />
#> [1] a<br />
#> Levels: a b<br />
z[1, drop = TRUE]<br />
#> [1] a<br />
#> Levels: a<br />
a <- matrix(1:4, nrow = 2)<br />
a[1, , drop = FALSE]<br />
#>      [,1] [,2]<br />
#> [1,]    1    3<br />
a[1, ]<br />
#> [1] 1 3<br />
df <- data.frame(a = 1:2, b = 1:2)<br />
str(df[1])<br />
#> 'data.frame':    2 obs. of  1 variable:<br />
#>  $ a: int  1 2<br />
str(df[[1]])<br />
#>  int [1:2] 1 2<br />
str(df[, "a", drop = FALSE])<br />
#> 'data.frame':    2 obs. of  1 variable:<br />
#>  $ a: int  1 2<br />
str(df[, "a"])<br />
#>  int [1:2] 1 2

不用多说，都在代码和表格的对照中！有了这个概念，我相信大家以后在比如对矩阵提取子集的时候，出现了向量的结果或者仍然是矩阵的结果心理都有个数了吧。

PS:表格有点歪，放入标签调整了还是歪的[s:12]

superdesolator

61.子集Subsetting operator $

这个也是df中常用的它x$abc等价于x[['abc']]，唯一要说的是：

x <- list(abc = 1)<br />
x$a<br />
#> [1] 1<br />
x[["a"]]<br />
#> NULL

这是个$ does partial matching，我们可以options(warnPartialMatchDollar = TRUE)来避免

superdesolator

62.缺失或越界时的表现[,[[

<br />
#Operator  Index	Atomic	List<br />
#[	   OOB	       NA	list(NULL)<br />
#[	   NA_real_      NA	list(NULL)<br />
#[	   NULL	       x[0]    list(NULL)<br />
#[[	  OOB	       Error   Error<br />
#[[       NA_real_     Error   NULL<br />
#[[       NULL	       Error   Error

OOB，表示out of bound，这个表格还是能解释一定行为的

还有一点注意：如果向量是被named,会出现<NA>

不过比较专业了，大家也就随便读读。。。以下是具体实验，大家自己也可以试试

R>x=1:3<br />
R>x<br />
[1] 1 2 3<br />
R>y=list(a=1:3,b=2:4)<br />
R>y<br />
$a<br />
[1] 1 2 3</p>
<p>$b<br />
[1] 2 3 4</p>
<p>R>x[4]<br />
[1] NA<br />
R>y[3]<br />
$<NA><br />
NULL</p>
<p>R>x[NA_real_]<br />
[1] NA<br />
R>y[NA_real_]<br />
$<NA><br />
NULL</p>
<p>R>x[NULL]<br />
integer(0)<br />
R>x[0]<br />
integer(0)<br />
R>y[NULL]<br />
named list()<br />
R>x[[4]]<br />
Error in x[[4]] : subscript out of bounds<br />
R>y[[3]]<br />
Error in y[[3]] : subscript out of bounds<br />
R>x[[NA_real_]]<br />
Error in x[[NA_real_]] : subscript out of bounds<br />
R>y[[NA_real_]]<br />
NULL<br />
R>x[[NULL]]<br />
Error in x[[NULL]] : attempt to select less than one element<br />
R>y[[NULL]]<br />
Error in y[[NULL]] : attempt to select less than one element

这里的目的，其实我觉得蛮好，就是出现这种意外的时候，我们可以预料出现什么的结果，或是推测原因，即比如我们知道用的是list,然后用的是[[,出现了NULL，结果可能是传入了NA_real_

superdesolator

63.subsetting的一些基本应用

很多高级的方法都是在这些应用基础上的

1.Lookup tables (character subsetting)

x <- c("m", "f", "u", "f", "f", "m", "m")<br />
lookup <- c(m = "Male", f = "Female", u = NA)<br />
lookup[x]

所以named vector还是很有用的！

2.Matching and merging by hand (integer subsetting)

grades<br />
#> [1] 1 2 2 3 1</p>
<p># Using match<br />
id <- match(grades, info$grade)<br />
info[id, ]<br />
#>     grade      desc  fail<br />
#> 3       1      Poor  TRUE<br />
#> 2       2      Good FALSE<br />
#> 2.1     2      Good FALSE<br />
#> 1       3 Excellent FALSE<br />
#> 3.1     1      Poor  TRUE</p>
<p># Using rownames<br />
rownames(info) <- info$grade<br />
info[as.character(grades), ]<br />
#>     grade      desc  fail<br />
#> 1       1      Poor  TRUE<br />
#> 2       2      Good FALSE<br />
#> 2.1     2      Good FALSE<br />
#> 3       3 Excellent FALSE<br />
#> 1.1     1      Poor  TRUE

可以看到2种方式都可以，我偏向第1种

3.Random samples/bootstrap (integer subsetting)

4.Ordering (integer subsetting)

5.Expanding aggregated counts (integer subsetting)

这些大家应该都比较熟悉，就是在数据框中用sample,order,rep取子集

6.Boolean algebra vs sets (logical & integer subsetting)

这个要注意下

a <- sample(10)<br />
a[a < 4]<br />
a[which(a<4)]

这两段结果一样，但后者更快,它用which，convert a boolean representation to an integer representation

这个东西大家常用，可能不太注意，下面顺带比较一下二者的运算

(x1 <- 1:10 %% 2 == 0)<br />
#>  [1] FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE<br />
(x2 <- which(x1))<br />
#> [1]  2  4  6  8 10<br />
(y1 <- 1:10 %% 5 == 0)<br />
#>  [1] FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE<br />
(y2 <- which(y1))<br />
#> [1]  5 10</p>
<p># X & Y <-> intersect(x, y)<br />
x1 & y1<br />
#>  [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE<br />
intersect(x2, y2)<br />
#> [1] 10</p>
<p># X | Y <-> union(x, y)<br />
x1 | y1<br />
#>  [1] FALSE  TRUE FALSE  TRUE  TRUE  TRUE FALSE  TRUE FALSE  TRUE<br />
union(x2, y2)<br />
#> [1]  2  4  6  8 10  5</p>
<p># X & !Y <-> setdiff(x, y)<br />
x1 & !y1<br />
#>  [1] FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE FALSE<br />
setdiff(x2, y2)<br />
#> [1] 2 4 6 8</p>
<p># xor(X, Y) <-> setdiff(union(x, y), intersect(x, y))<br />
xor(x1, y1)<br />
#>  [1] FALSE  TRUE FALSE  TRUE  TRUE  TRUE FALSE  TRUE FALSE FALSE<br />
setdiff(union(x2, y2), intersect(x2, y2))<br />
#> [1] 2 4 6 8 5

7.最后要注意的是x[]

<br />
x=matrix(1:4,2)<br />
x[]=0<br />
x=0