• 粉丝日志首页

用R语言把数据玩出花样

R的极客理想系列文章,涵盖了R的思想,使用,工具,创新等的一系列要点,以我个人的学习和体验去诠释R的强大。

R语言作为统计学一门语言,一直在小众领域闪耀着光芒。直到大数据的爆发,R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入,R语言的社区在迅速扩大成长。现在已不仅仅是统计领域,教育,银行,电商,互联网….都在使用R语言。

要成为有理想的极客,我们不能停留在语法上,要掌握牢固的数学,概率,统计知识,同时还要有创新精神,把R语言发挥到各个领域。让我们一起动起来吧,开始R的极客理想。

关于作者:

  • 张丹, 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/r-transform/

前言

作为数据分析师,每天都有大量的数据需要处理,我们会根据业务的要求做各种复杂的报表,包括了分组、排序、过滤、转置、差分、填充、移动、合并、分裂、分布、去重、找重、填充 等等的操作。

有时为了计算一个业务指标,你的SQL怎么写都不会少于10行时,另外你可能也会抱怨Excel功能不够强大,这个时候R语言绝对是不二的选择了。用R语言可以高效地、优雅地解决数据处理的问题,让R来帮你打开面向数据的思维模式。

目录

  1. 为什么要用R语言做数据处理?
  2. 数据处理基础
  3. 个性化的数据变换需求

1. 为什么要用R语言做数据处理?

R语言是非常适合做数据处理的编程语言,因为R语言的设计理念,就是面向数据的,为了解决数据问题。读完本文,相信你就能明白,什么是面向数据的设计了。

一个BI工程师每天的任务,都是非常繁琐的数据处理,如果用Java来做简直就是折磨,但是换成R语言来做,你会找到乐趣的。

当接到一个数据处理的任务后,我们可以把任务拆解为很多小的操作,包括了分组、排序、过滤、转置、差分、填充、移动、合并、分裂、分布、去重、找重等等的操作。对于实际应用的复杂的操作来说,就是把这些小的零碎的操作,拼装起来就好了。

在开始之前,我们要先了解一下R语言支持的数据类型,以及这些常用类型的特点。对于BI的数据处理的工作来说,可能有4种类型是最常用的,分别是向量、矩阵、数据框、时间序列。

  • 向量 Vector : c()
  • 矩阵 Matrix: matrix()
  • 数据框 DataFrame: data.frame()
  • 时间序列 XTS: xts()

我主要是用R语言来做量化投资,很多的时候,都是和时间序列类型数据打交道,所以我把时间序列,也定义为R语言最常用的数据处理的类型。时间序列类型,使用的是第三方包xts中定义的类型。

2. 数据处理基础

本机的系统环境:

  • Win10 64bit
  • R: version 3.2.3 64bit

2.1 创建一个数据集

创建一个向量数据集。


> x<-1:20;x
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

创建一个矩阵数据集。


> m<-matrix(1:40,ncol=5);m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    9   17   25   33
[2,]    2   10   18   26   34
[3,]    3   11   19   27   35
[4,]    4   12   20   28   36
[5,]    5   13   21   29   37
[6,]    6   14   22   30   38
[7,]    7   15   23   31   39
[8,]    8   16   24   32   40

创建一个数据框数据集。


> df<-data.frame(a=1:5,b=c('A','A','B','B','A'),c=rnorm(5));df
  a b          c
1 1 A  1.1519118
2 2 A  0.9921604
3 3 B -0.4295131
4 4 B  1.2383041
5 5 A -0.2793463

创建一个时间序列数据集,时间序列使用的第三方的xts类型。关于xts类型的详细介绍,请参考文章 可扩展的时间序列xts。


> library(xts)
> xts(1:10,order.by=as.Date('2017-01-01')+1:10)
           [,1]
2017-01-02    1
2017-01-03    2
2017-01-04    3
2017-01-05    4
2017-01-06    5
2017-01-07    6
2017-01-08    7
2017-01-09    8
2017-01-10    9
2017-01-11   10

2.2 查看数据概况

通常进行数据分析的第一步是,查看一下数据的概况信息,在R语言里可以使用summary()函数来完成。


# 查看矩阵数据集的概况
> m<-matrix(1:40,ncol=5)
> summary(m)
       V1             V2              V3              V4              V5       
 Min.   :1.00   Min.   : 9.00   Min.   :17.00   Min.   :25.00   Min.   :33.00  
 1st Qu.:2.75   1st Qu.:10.75   1st Qu.:18.75   1st Qu.:26.75   1st Qu.:34.75  
 Median :4.50   Median :12.50   Median :20.50   Median :28.50   Median :36.50  
 Mean   :4.50   Mean   :12.50   Mean   :20.50   Mean   :28.50   Mean   :36.50  
 3rd Qu.:6.25   3rd Qu.:14.25   3rd Qu.:22.25   3rd Qu.:30.25   3rd Qu.:38.25  
 Max.   :8.00   Max.   :16.00   Max.   :24.00   Max.   :32.00   Max.   :40.00  

# 查看数据框数据集的概况信息
> df<-data.frame(a=1:5,b=c('A','A','B','B','A'),c=rnorm(5))
> summary(df)
       a     b           c          
 Min.   :1   A:3   Min.   :-1.5638  
 1st Qu.:2   B:2   1st Qu.:-1.0656  
 Median :3         Median :-0.2273  
 Mean   :3         Mean   :-0.1736  
 3rd Qu.:4         3rd Qu.: 0.8320  
 Max.   :5         Max.   : 1.1565  

通过查看概况,可以帮助我们简单了解数据的一些统计特征。

2.3 数据合并

我们经常需要对于数据集,进行合并操作,让数据集满足处理的需求。对于不同类型的数据集,有不同的处理方法。

向量类型


> x<-1:5
> y<-11:15
> c(x,y)
 [1]  1  2  3  4  5 11 12 13 14 15

数据框类型的合并操作。


> df<-data.frame(a=1:5,b=c('A','A','B','B','A'),c=rnorm(5));df
  a b          c
1 1 A  1.1519118
2 2 A  0.9921604
3 3 B -0.4295131
4 4 B  1.2383041
5 5 A -0.2793463

# 合并新行
> rbind(df,c(11,'A',222))
   a b                  c
1  1 A    1.1519117540872
2  2 A  0.992160365445798
3  3 B -0.429513109491881
4  4 B   1.23830410085338
5  5 A -0.279346281854269
6 11 A                222

# 合并新列
> cbind(df,x=LETTERS[1:5])
  a b          c x
1 1 A  1.1519118 A
2 2 A  0.9921604 B
3 3 B -0.4295131 C
4 4 B  1.2383041 D
5 5 A -0.2793463 E

# 合并新列
> merge(df,LETTERS[3:5])
   a b          c y
1  1 A  1.1519118 C
2  2 A  0.9921604 C
3  3 B -0.4295131 C
4  4 B  1.2383041 C
5  5 A -0.2793463 C
6  1 A  1.1519118 D
7  2 A  0.9921604 D
8  3 B -0.4295131 D
9  4 B  1.2383041 D
10 5 A -0.2793463 D
11 1 A  1.1519118 E
12 2 A  0.9921604 E
13 3 B -0.4295131 E
14 4 B  1.2383041 E
15 5 A -0.2793463 E

2.4 累计计算

累计计算,是很常用的一种计算方法,就是把每个数值型的数据,累计求和或累计求积,从而反应数据的增长的一种特征。


# 向量x
> x<-1:10;x
 [1]  1  2  3  4  5  6  7  8  9 10

# 累计求和
> cum_sum<-cumsum(x)

# 累计求积
> cum_prod<-cumprod(x)

# 拼接成data.frame
> data.frame(x,cum_sum,cum_prod)
    x cum_sum cum_prod
1   1       1        1
2   2       3        2
3   3       6        6
4   4      10       24
5   5      15      120
6   6      21      720
7   7      28     5040
8   8      36    40320
9   9      45   362880
10 10      55  3628800

我们通常用累计计算,记录中间每一步的过程,看到的数据处理过程的特征。

2.5 差分计算

差分计算,是用向量的后一项减去前一项,所获得的差值,差分的结果反映了离散量之间的一种变化。


> x<-1:10;x
 [1]  1  2  3  4  5  6  7  8  9 10

# 计算1阶差分
> diff(x)
[1] 1 1 1 1 1 1 1 1 1

# 计算2阶差分
> diff(x,2)
[1] 2 2 2 2 2 2 2 2

# 计算2阶差分,迭代2次
> diff(x,2,2)
[1] 0 0 0 0 0 0

下面做一个稍微复杂一点的例子,通过差分来发现数据的规律。


# 对向量2次累积求和
> x <- cumsum(cumsum(1:10));x
 [1]   1   4  10  20  35  56  84 120 165 220

# 计算2阶差分
> diff(x, lag = 2)
[1]   9  16  25  36  49  64  81 100

# 计算1阶差分,迭代2次
> diff(x, differences = 2)
[1]  3  4  5  6  7  8  9 10

# 同上
> diff(diff(x))
[1]  3  4  5  6  7  8  9 10

差分其实是很常见数据的操作,但这种操作是SQL很难表达的,所以可能会被大家所忽视。

2.6 分组计算

分组是SQL中,支持的一种数据变换的操作,对应于group by的语法。

比如,我们写一个例子。创建一个数据框有a,b,c的3列,其中a,c列为数值型,b列为字符串,我们以b列分组,求出a列与c的均值。


# 创建数据框
> df<-data.frame(a=1:5,b=c('A','A','B','B','A'),c=rnorm(5));df
  a b           c
1 1 A  1.28505418
2 2 A -0.04687263
3 3 B  0.25383533
4 4 B  0.70145787
5 5 A -0.11470372

# 执行分组操作
> aggregate(. ~ b, data = df, mean)
  b        a         c
1 A 2.666667 0.3744926
2 B 3.500000 0.4776466

同样的数据集,以b列分组,对a列求和,对c列求均值。当对不同列,进行不同的操作时,我们同时也需要换其他函数来处理。


# 加载plyr库
> library(plyr)

# 执行分组操作
> ddply(df,.(b),summarise,
+       sum_a=sum(a),
+       mean_c=mean(c))
  b sum_a      mean_c
1 A     8 -0.05514761
2 B     7  0.82301276

生成的结果,就是按b列进行分组后,a列求和,c列求均值。

2.7 分裂计算

分裂计算,是把一个向量按照一列规则,拆分成多个向量的操作。

如果你想把1:10的向量,按照单双数,拆分成2个向量。


> split(1:10, 1:2)
$`1`
[1] 1 3 5 7 9

$`2`
[1]  2  4  6  8 10

另外,可以用因子类型来控制分裂。分成2步操作,第一步先分成与数据集同样长度的因子,第二步进行分裂,可以把一个大的向量拆分成多个小的向量。


# 生成因子规则
> n <- 3; size <- 5
> fat <- factor(round(n * runif(n * size)));fat
 [1] 2 3 2 1 1 0 0 2 0 1 2 3 1 1 1
Levels: 0 1 2 3

# 生成数据向量
> x <- rnorm(n * size);x
 [1]  0.68973936  0.02800216 -0.74327321  0.18879230 -1.80495863  1.46555486  0.15325334  2.17261167  0.47550953
[10] -0.70994643  0.61072635 -0.93409763 -1.25363340  0.29144624 -0.44329187

# 对向量以因子的规则进行拆分
> split(x, fat)
$`0`
[1] 1.4655549 0.1532533 0.4755095

$`1`
[1]  0.1887923 -1.8049586 -0.7099464 -1.2536334  0.2914462 -0.4432919

$`2`
[1]  0.6897394 -0.7432732  2.1726117  0.6107264

$`3`
[1]  0.02800216 -0.93409763

这种操作可以非常有效地,对数据集进行分类整理,比if..else的操作,有本质上的提升。

2.8 排序

排序是所有数据操作中,最常见一种需求了。在R语言中,你可以很方便的使用排序的功能,并不用考虑时间复杂度与空间复杂度的问题,除非你自己非要用for循环来实现。

对向量进行排序。


# 生成一个乱序的向量
> x<-sample(1:10);x
 [1]  6  2  5  1  9 10  8  3  7  4

# 对向量排序 
> x[order(x)]
 [1]  1  2  3  4  5  6  7  8  9 10

以数据框某一列进行排序。


> df<-data.frame(a=1:5,b=c('A','A','B','B','A'),c=rnorm(5));df
  a b          c
1 1 A  1.1780870
2 2 A -1.5235668
3 3 B  0.5939462
4 4 B  0.3329504
5 5 A  1.0630998

# 自定义排序函数 
> order_df<-function(df,col,decreasing=FALSE){
+     df[order(df[,c(col)],decreasing=decreasing),]
+ }

# 以c列倒序排序
> order_df(df,'c',decreasing=TRUE)
  a b          c
1 1 A  1.1780870
5 5 A  1.0630998
3 3 B  0.5939462
4 4 B  0.3329504
2 2 A -1.5235668

排序的操作,大多都是基于索引来完成的,用order()函数来生成索引,再匹配的数据的数值上面。

2.9 去重与找重

去重,是把向量中重复的元素过滤掉。找重,是把向量中重复的元素找出来。


> x<-c(3:6,5:8);x
[1] 3 4 5 6 5 6 7 8

# 去掉重复元素
> unique(x)
[1] 3 4 5 6 7 8

# 找到重复元素,索引位置
> duplicated(x)
[1] FALSE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE

# 找到重复元素
> x[duplicated(x)]
[1] 5 6

2.10 转置

转置是一个数学名词,把行和列进行互换,一般用于对矩阵的操作。


# 创建一个3行5列的矩阵
> m<-matrix(1:15,ncol=5);m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    4    7   10   13
[2,]    2    5    8   11   14
[3,]    3    6    9   12   15

# 转置后,变成5行3列的矩阵
> t(m)
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9
[4,]   10   11   12
[5,]   13   14   15

2.11 过滤

过滤,是对数据集按照某种规则进行筛选,去掉不符合条件的数据,保留符合条件的数据。对于NA值的操作,主要都集中在了过滤操作和填充操作中,因此就不在单独介绍NA值的处理了。


# 生成数据框
> df<-data.frame(a=c(1,NA,NA,2,NA),
+     b=c('B','A','B','B',NA),
+     c=c(rnorm(2),NA,NA,NA));df
   a    b          c
1  1    B -0.3041839
2 NA    A  0.3700188
3 NA    B         NA
4  2    B         NA
5 NA <NA>         NA

# 过滤有NA行的数据
> na.omit(df)
  a b          c
1 1 B -0.3041839

# 过滤,保留b列值为B的数据
> df[which(df$b=='B'),]
   a b          c
1  1 B -0.3041839
3 NA B         NA
4  2 B         NA

过滤,类似与SQL语句中的 WHERE 条件语句,如果你用100个以上的过滤条件,那么你的程序就会比较复杂了,最好想办法用一些巧妙的函数或者设计模式,来替换这些过滤条件。

2.12 填充

填充,是一个比较有意思的操作,你的原始数据有可能会有缺失值NA,在做各种计算时,就会出现有问题。一种方法是,你把NA值都去掉;另外一种方法是,你把NA值进行填充后再计算。那么在填充值时,就有一些讲究了。

把NA值进行填充。


# 生成数据框
> df<-data.frame(a=c(1,NA,NA,2,NA),
+      b=c('B','A','B','B',NA),
+      c=c(rnorm(2),NA,NA,NA));df
   a    b          c
1  1    B  0.2670988
2 NA    A -0.5425200
3 NA    B         NA
4  2    B         NA
5 NA <NA>         NA

# 把数据框a列的NA,用9进行填充
> na.fill(df$a,9)
[1] 1 9 9 2 9

# 把数据框中的NA,用1进行填充
> na.fill(df,1)
     a      b      c           
[1,] " 1"   "B"    " 0.2670988"
[2,] "TRUE" "A"    "-0.5425200"
[3,] "TRUE" "B"    "TRUE"      
[4,] " 2"   "B"    "TRUE"      
[5,] "TRUE" "TRUE" "TRUE"     

填充时,有时并不是用某个固定的值,而是需要基于某种规则去填充。


# 生成一个zoo类型的数据
> z <- zoo(c(2, NA, 1, 4, 5, 2), c(1, 3, 4, 6, 7, 8));z
 1  3  4  6  7  8 
 2 NA  1  4  5  2 

# 对NA进行线性插值
> na.approx(z) 
       1        3        4        6        7        8 
2.000000 1.333333 1.000000 4.000000 5.000000 2.000000 

# 对NA进行线性插值
> na.approx(z, 1:6)
  1   3   4   6   7   8 
2.0 1.5 1.0 4.0 5.0 2.0 

# 对NA进行样条插值
> na.spline(z)
        1         3         4         6         7         8 
2.0000000 0.1535948 1.0000000 4.0000000 5.0000000 2.0000000 

另外,我们可以针对NA的位置进行填充,比如用前值来填充或后值来填充。


> df
   a    b          c
1  1    B  0.2670988
2 NA    A -0.5425200
3 NA    B         NA
4  2    B         NA
5 NA <NA>         NA

# 用当前列中,NA的前值来填充
> na.locf(df)
   a b          c
1  1 B  0.2670988
2  1 A -0.5425200
3  1 B -0.5425200
4  2 B -0.5425200
5  2 B -0.5425200

# 用当前列中,NA的后值来填充
> na.locf(df,fromLast=TRUE)
   a b          c
1  1 B  0.2670988
2  2 A -0.5425200
3  2 B       <NA>
4  2 B       <NA>

2.13 计数

计数,是统计同一个值出现的次数。


# 生成30个随机数的向量
> set.seed(0)
> x<-round(rnorm(30)*5);x
 [1]  6 -2  7  6  2 -8 -5 -1  0 12  4 -4 -6 -1 -1 -2  1 -4  2 -6 -1  2  1  4  0  3  5 -3 -6  0

# 统计每个值出现的次数
> table(x)
x
-8 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7 12 
 1  3  1  2  1  2  4  3  2  3  1  2  1  2  1  1 

用直方图画出。


> hist(x,xlim = c(-10,13),breaks=20)

2.14 统计分布

统计分布,是用来判断数据是否是满足某种统计学分布,如果能够验证了,那么我们就可以用到这种分布的特性来理解我们的数据集的情况了。常见的连续型的统计分布有9种,其中最常用的就是正态分布的假设。关于统计分布的详细介绍,请参考文章 常用连续型分布介绍及R语言实现

  • runif() :均匀分布
  • rnorm() :正态分布
  • rexp() :指数分布
  • rgamma() :伽马分布
  • rweibull() :韦伯分布
  • rchisq() :卡方分布
  • rf() :F分布
  • rt() :T分布
  • rbeta() :贝塔分布

统计模型定义的回归模型,就是基于正态分布的做的数据假设,如果残差满足正态分布,模型的指标再漂亮都是假的。如果你想进一步了解回归模型,请参考文章R语言解读一元线性回归模型

下面用正态分布,来举例说明一下。假设我们有一组数据,是人的身高信息,我们知道平均身高是170cm,然后我们算一下,这组身高数据是否满足正态分布。


# 生成身高数据
> set.seed(1)
> x<-round(rnorm(100,170,10))
> head(x,20)
 [1] 164 172 162 186 173 162 175 177 176 167 185 174 164 148 181 170 170 179 178 176

# 画出散点图 
> plot(x)

通过散点图来观察,发现数据是没有任何规律。接下来,我们进行正态分布的检验,Shapiro-Wilk进行正态分布检验。


> shapiro.test(x)
	Shapiro-Wilk normality test
data:  x
W = 0.99409, p-value = 0.9444

该检验原假设为H0:数据集符合正态分布,统计量W为。统计量W的最大值是1,越接近1,表示样本与正态分布越匹配。p值,如果p-value小于显著性水平α(0.05),则拒绝H0。检验结论: W接近1,p-value>0.05,不能拒绝原假设,所以数据集S符合正态分布!

同时,我们也可以用QQ图,来做正态分布的检验。


> qqnorm(x)
> qqline(x,col='red')

图中,散点均匀的分布在对角线,则说明这组数据符合正态分布。

为了,更直观地对正态分布的数据进行观察,我们可以用上文中计数操作时,使用的直方图进行观察。


> hist(x,breaks=10)

通过计数的方法,发现数据形状如钟型,中间高两边低,中间部分的数量占了95%,这就是正态的特征。当判断出,数据是符合正态分布后,那么才具备了可以使用一些的模型的基础。

2.15 数值分段

数值分段,就是把一个连续型的数值型数据,按区间分割为因子类型的离散型数据。


> x<-1:10;x
 [1]  1  2  3  4  5  6  7  8  9 10

# 把向量转换为3段因子,分别列出每个值对应因子
> cut(x, 3)
 [1] (0.991,4] (0.991,4] (0.991,4] (0.991,4] (4,7]     (4,7]     (4,7]     (7,10]    (7,10]    (7,10]   
Levels: (0.991,4] (4,7] (7,10]

# 对因子保留2位精度,并支持排序
> cut(x, 3, dig.lab = 2, ordered = TRUE)
 [1] (0.99,4] (0.99,4] (0.99,4] (0.99,4] (4,7]    (4,7]    (4,7]    (7,10]   (7,10]   (7,10]  
Levels: (0.99,4] < (4,7] < (7,10]

2.16 集合操作

集合操作,是对2个向量的操作,处理2个向量之间的数值的关系,找到包含关系、取交集、并集、差集等。


# 定义2个向量x,y
> x<-c(3:8,NA);x
[1]  3  4  5  6  7  8 NA
> y<-c(NA,6:10,NA);y
[1] NA  6  7  8  9 10 NA

# 判断x与y重复的元素的位置
> is.element(x, y)
[1] FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE

# 判断y与x重复的元素的位置
> is.element(y, x)
[1]  TRUE  TRUE  TRUE  TRUE FALSE FALSE  TRUE

# 取并集
> union(x, y)
[1]  3  4  5  6  7  8 NA  9 10

# 取交集
> intersect(x, y)
[1]  6  7  8 NA

# 取x有,y没有元素
> setdiff(x, y)
[1] 3 4 5

# 取y有,x没有元素
> setdiff(y, x)
[1]  9 10

# 判断2个向量是否相等
> setequal(x, y)
[1] FALSE

2.17 移动窗口

移动窗口,是用来按时间周期观察数据的一种方法。移动平均,就是一种移动窗口的最常见的应用了。

在R语言的的TTR包中,支持多种的移动窗口的计算。

  • runMean(x) :移动均值
  • runSum(x) :移动求和
  • runSD(x) :移动标准差
  • runVar(x) :移动方差
  • runCor(x,y) :移动相关系数
  • runCov(x,y) :移动协方差
  • runMax(x) :移动最大值
  • runMin(x) :移动最小值
  • runMedian(x):移动中位数

下面我们用移动平均来举例说明一下,移动平均在股票交易使用的非常普遍,是最基础的趋势判断的根踪指标了。


# 生成50个随机数
> set.seed(0)
> x<-round(rnorm(50)*10);head(x,10)
 [1]  13  -3  13  13   4 -15  -9  -3   0  24

# 加载TTR包
> library(TTR)

# 计算周期为3的移动平均值
> m3<-SMA(x,3);head(m3,10)
 [1]         NA         NA  7.6666667  7.6666667 10.0000000  0.6666667 -6.6666667 -9.0000000 -4.0000000
[10]  7.0000000

# 计算周期为5的移动平均值
> m5<-SMA(x,5);head(m5,10)
 [1]   NA   NA   NA   NA  8.0  2.4  1.2 -2.0 -4.6 -0.6

当计算周期为3的移动平均值时,结果的前2个值是NA,计算的算法是


(第一个值 + 第二个值 + 第三个值)  /3 = 第三个值的移动平均值
(13      +    -3   +     13)    /3 = 7.6666667

画出图形


> plot(x,type='l')
> lines(m3,col='blue')
> lines(m5,col='red')

图中黑色线是原始数据,蓝色线是周期为3的移动平均值,红色线是周期为5的移动平均值。这3个线中,周期越大的越平滑,红色线波动是最小的,趋势性是越明显的。如果你想更深入的了解移动平均线在股票中的使用情况,请参考文章二条均线打天下

2.18 时间对齐

时间对齐,是在处理时间序列类型时常用到的操作。我们在做金融量化分析时,经常遇到时间不齐的情况,比如某支股票交易很活跃,每一秒都有交易,而其他不太活跃的股票,可能1分钟才有一笔交易,当我们要同时分析这2只股票的时候,就需要把他们的交易时间进行对齐。


# 生成数据,每秒一个值
> a<-as.POSIXct("2017-01-01 10:00:00")+0:300

# 生成数据,每59秒一个值
> b<-as.POSIXct("2017-01-01 10:00")+seq(1,300,59)

# 打印a
> head(a,10)
 [1] "2017-01-01 10:00:00 CST" "2017-01-01 10:00:01 CST" "2017-01-01 10:00:02 CST" "2017-01-01 10:00:03 CST"
 [5] "2017-01-01 10:00:04 CST" "2017-01-01 10:00:05 CST" "2017-01-01 10:00:06 CST" "2017-01-01 10:00:07 CST"
 [9] "2017-01-01 10:00:08 CST" "2017-01-01 10:00:09 CST"

# 打印b 
> head(b,10)
[1] "2017-01-01 10:00:01 CST" "2017-01-01 10:01:00 CST" "2017-01-01 10:01:59 CST" "2017-01-01 10:02:58 CST"
[5] "2017-01-01 10:03:57 CST" "2017-01-01 10:04:56 CST"

按分钟进行对齐,把时间都对齐到分钟线上。


# 按分钟对齐
> a1<-align.time(a, 1*60)
> b1<-align.time(b, 1*60)

# 查看对齐后的结果
> head(a1,10)
 [1] "2017-01-01 10:01:00 CST" "2017-01-01 10:01:00 CST" "2017-01-01 10:01:00 CST" "2017-01-01 10:01:00 CST"
 [5] "2017-01-01 10:01:00 CST" "2017-01-01 10:01:00 CST" "2017-01-01 10:01:00 CST" "2017-01-01 10:01:00 CST"
 [9] "2017-01-01 10:01:00 CST" "2017-01-01 10:01:00 CST"

> head(b1,10)
[1] "2017-01-01 10:01:00 CST" "2017-01-01 10:02:00 CST" "2017-01-01 10:02:00 CST" "2017-01-01 10:03:00 CST"
[5] "2017-01-01 10:04:00 CST" "2017-01-01 10:05:00 CST"

由于a1数据集,每分钟有多条数据,取每分钟的最后一条代表这分钟就行。


> a1[endpoints(a1,'minutes')]
[1] "2017-01-01 10:01:00 CST" "2017-01-01 10:02:00 CST" "2017-01-01 10:03:00 CST" "2017-01-01 10:04:00 CST"
[5] "2017-01-01 10:05:00 CST" "2017-01-01 10:06:00 CST"

这样子就完成了时间对齐,把不同时间的数据放到都一个维度中了。

3. 个性化的数据变换需求

我们上面已经介绍了,很多种的R语言数据处理的方法,大多都是基于R语言内置的函数或第三方包来完成的。在实际的工作中,实际还有再多的操作,完全是各性化的。

3.1 过滤数据框中,列数据全部为空的列

空值,通常都会给我们做数值计算,带来很多麻烦。有时候一列的数据都是空时,我们需要先把这一个过滤掉,再进行数据处理。

用R语言程序进行实现


# 判断哪列的值都是NA
na_col_del_df<-function(df){
  df[,which(!apply(df,2,function(x) all(is.na(x))))]  
} 

# 生成一个数据集
> df<-data.frame(a=c(1,NA,2,4),b=rep(NA,4),c=1:4);df
   a  b c
1  1 NA 1
2 NA NA 2
3  2 NA 3
4  4 NA 4

# 保留非NA的列
> na_col_del_df(df)
   a c
1  1 1
2 NA 2
3  2 3
4  4 4

3.2 替换数据框中某个区域的数据

我们想替换数据框中某个区域的数据,那么应该怎么做呢?

找到第一个数据框中,与第二个数据框中匹配的行的值作为条件,然后替换这一行的其他指定列的值。


> replace_df<-function(df1,df2,keys,vals){
+     row1<-which(apply(mapply(match,df1[,keys],df2[,keys])>0,1,all))
+     row2<-which(apply(mapply(match,df2[,keys],df1[,keys])>0,1,all))
+     df1[row1,vals]<-df2[row2,vals]
+     return(df1)
+ }

# 第一个数据框 
> df1<-data.frame(A=c(1,2,3,4),B=c('a','b','c','d'),C=c(0,4,0,4),D=1:4);df1
  A B C D
1 1 a 0 1
2 2 b 4 2
3 3 c 0 3
4 4 d 4 4

# 第二个数据框 
> df2<-data.frame(A=c(1,3),B=c('a','c'),C=c(9,9),D=rep(8,2));df2
  A B C D
1 1 a 9 8
2 3 c 9 8

# 定义匹配条件列 
> keys=c("A","B")

# 定义替换的列
> vals=c("C","D")

# 数据替换
> replace_df(df1,df2,keys,vals)
  A B C D
1 1 a 9 8
2 2 b 4 2
3 3 c 9 8
4 4 d 4 4

其实不管R语言中,各种内置的功能函数有多少,自己做在数据处理的时候,都要自己构建很多DIY的函数。

3.3 长表和宽表变换

长宽其实是一种类对于标准表格形状的描述,长表变宽表,是把一个行数很多的表,让其行数减少,列数增加,宽表变长表,是把一个表格列数减少行数增加。

长表变宽表,指定program列不动,用fun列的每一行,生成新的列,再用time列的每个值进行填充。


# 创建数据框
> df<-data.frame(
+     program=rep(c('R','Java','PHP','Python'),3),
+     fun=rep(c('fun1','fun2','fun3'),each = 4),
+     time=round(rnorm(12,10,3),2)
+ );df
   program  fun  time
1        R fun1 10.91
2     Java fun1  6.59
3      PHP fun1  9.26
4   Python fun1 11.17
5        R fun2 12.27
6     Java fun2  6.61
7      PHP fun2  7.28
8   Python fun2  9.39
9        R fun3  9.22
10    Java fun3 11.20
11     PHP fun3 13.40
12  Python fun3 10.67

# 加载reshape2库
> library(reshape2)

# 长表变宽表
> wide <- reshape(df,v.names="time",idvar="program",timevar="fun",direction = "wide");wide
  program time.fun1 time.fun2 time.fun3
1       R     10.91     12.27      9.22
2    Java      6.59      6.61     11.20
3     PHP      9.26      7.28     13.40
4  Python     11.17      9.39     10.67

接下来,进行反正操作,把宽表再转换为长表,还是使用reshape()函数。


# 宽表变为长表
> reshape(wide, direction = "long")
            program  fun  time
R.fun1            R fun1  8.31
Java.fun1      Java fun1  8.45
PHP.fun1        PHP fun1 10.49
Python.fun1  Python fun1 10.45
R.fun2            R fun2  8.72
Java.fun2      Java fun2  4.15
PHP.fun2        PHP fun2 11.47
Python.fun2  Python fun2 13.25
R.fun3            R fun3 10.10
Java.fun3      Java fun3 13.86
PHP.fun3        PHP fun3  9.96
Python.fun3  Python fun3 14.64

我们在宽表转换为长表时,可以指定想转换部分列,而不是所有列,这样就需要增加一个参数进行控制。比如,只变换time.fun2,time.fun3列到长表,而不变换time.fun1列。


> reshape(wide, direction = "long", varying =3:4)
       program time.fun1  time id
1.fun2       R      8.31  8.72  1
2.fun2    Java      8.45  4.15  2
3.fun2     PHP     10.49 11.47  3
4.fun2  Python     10.45 13.25  4
1.fun3       R      8.31 10.10  1
2.fun3    Java      8.45 13.86  2
3.fun3     PHP     10.49  9.96  3
4.fun3  Python     10.45 14.64  4

这样子的转换变形,是非常有利于我们从多角度来看数据的。

3.4 融化

融化,用于把以列进行分组的数据,转型为按行存储,对应数据表设计的概念为,属性表设计。

我们设计一下标准的二维表结构,然后按属性表的方式进行转换。


# 构建数据集
> df<-data.frame(
+   id=1:10,
+   x1=rnorm(10),
+   x2=runif(10,0,1)
+ );df
   id          x1          x2
1   1  1.78375335 0.639933473
2   2  0.26424700 0.250290845
3   3 -1.83138689 0.963861236
4   4 -1.77029220 0.451004465
5   5 -0.92149552 0.322621217
6   6  0.88499153 0.697954226
7   7  0.68905343 0.002045145
8   8  1.35269693 0.765777220
9   9  0.03673819 0.908817646
10 10  0.49682503 0.413977373

# 融合,以id列为固定列
> melt(df, id="id")
   id variable        value
1   1       x1  1.783753346
2   2       x1  0.264247003
3   3       x1 -1.831386887
4   4       x1 -1.770292202
5   5       x1 -0.921495517
6   6       x1  0.884991529
7   7       x1  0.689053430
8   8       x1  1.352696934
9   9       x1  0.036738187
10 10       x1  0.496825031
11  1       x2  0.639933473
12  2       x2  0.250290845
13  3       x2  0.963861236
14  4       x2  0.451004465
15  5       x2  0.322621217
16  6       x2  0.697954226
17  7       x2  0.002045145
18  8       x2  0.765777220
19  9       x2  0.908817646
20 10       x2  0.413977373

这个操作其实在使用ggplot2包画图时,会被经常用到。因为ggplot2做可视化时画多条曲线时,要求的输入的数据格式必须时属性表的格式。

3.5 周期分割

周期分割,是基于时间序列类型数据的处理。比如黄金的交易,你可以用1天为周期来观察,也可以用的1小时为周期来观察,也可以用1分钟为周期来看。

下面我们尝试先生成交易数据,再对交易数据进行周期的分割。本例仅为周期分割操作的示范,数据为随机生成的,请不要对数据的真实性较真。


# 加载xts包
> library(xts)

# 定义生成每日交易数据函数
> newTick<-function(date='2017-01-01',n=30){
+   newDate<-paste(date,'10:00:00')
+   xts(round(rnorm(n,10,2),2),order.by=as.POSIXct(newDate)+seq(0,(n-1)*60,60))
+ }

假设我们要生成1年的交易数据,先产生1年的日期向量,然后循环生成每日的数据。


# 设置交易日期
> dates<-as.Date("2017-01-01")+seq(0,360,1)
> head(dates)
[1] "2017-01-01" "2017-01-02" "2017-01-03" "2017-01-04" "2017-01-05" "2017-01-06"

# 生成交易数据
> xs<-lapply(dates,function(date){
+   newTick(date)
+ })

# 查看数据静态结构
> str(head(xs,2))
List of 2
 $ :An ‘xts’ object on 2017-01-01 10:00:00/2017-01-01 10:29:00 containing:
  Data: num [1:30, 1] 9.98 9.2 10.21 9.08 7.82 ...
  Indexed by objects of class: [POSIXct,POSIXt] TZ: 
  xts Attributes:  
 NULL
 $ :An ‘xts’ object on 2017-01-02 10:00:00/2017-01-02 10:29:00 containing:
  Data: num [1:30, 1] 9.41 13.15 6.07 10.12 10.37 ...
  Indexed by objects of class: [POSIXct,POSIXt] TZ: 
  xts Attributes:  
 NULL

# 转型为xts类型 
> df<-do.call(rbind.data.frame, xs)
> xdf<-as.xts(df)
> head(xdf)
                       V1
2017-01-01 10:00:00  9.98
2017-01-01 10:01:00  9.20
2017-01-01 10:02:00 10.21
2017-01-01 10:03:00  9.08
2017-01-01 10:04:00  7.82
2017-01-01 10:05:00 10.47

现在有了数据,那么我们可以对数据日期,按周期的分割了,从而生成开盘价、最高价、最低价、收盘价。这里一样会用到xts包的函数。关于xts类型的详细介绍,请参考文章 可扩展的时间序列xts


# 按日进行分割,对应高开低收的价格
> d1<-to.period(xdf,period='days');head(d1)
                    xdf.Open xdf.High xdf.Low xdf.Close
2017-01-01 10:29:00     9.98    13.74    5.35     13.34
2017-01-02 10:29:00     9.41    13.54    6.07      9.76
2017-01-03 10:29:00    12.11    13.91    7.16     10.75
2017-01-04 10:29:00    10.43    14.02    6.31     12.10
2017-01-05 10:29:00    11.51    13.97    6.67     13.97
2017-01-06 10:29:00    10.57    12.81    4.30      5.16

# 按月进行分割
> m1<-to.period(xdf,period='months');m1
                    xdf.Open xdf.High xdf.Low xdf.Close
2017-01-31 10:29:00     9.98    16.40    3.85     10.14
2017-02-28 10:29:00     8.25    16.82    4.17     11.76
2017-03-31 10:29:00    10.55    15.54    2.77      9.61
2017-04-30 10:29:00     9.40    16.13    3.84     11.77
2017-05-31 10:29:00    13.79    16.74    3.97     10.25
2017-06-30 10:29:00     9.29    16.15    4.38      7.92
2017-07-31 10:29:00     5.39    16.09    4.55      9.88
2017-08-31 10:29:00     5.76    16.34    3.27     10.86
2017-09-30 10:29:00     9.56    16.40    3.58     10.09
2017-10-31 10:29:00     8.64    15.50    3.23     10.26
2017-11-30 10:29:00     9.20    15.38    3.00     10.92
2017-12-27 10:29:00     6.99    16.22    3.87      8.87

# 按7日进行分割
> d7<-to.period(xdf,period='days',k=7);head(d7)
                    xdf.Open xdf.High xdf.Low xdf.Close
2017-01-07 10:29:00     9.98    15.54    4.30     10.42
2017-01-14 10:29:00    11.38    14.76    5.74      9.17
2017-01-21 10:29:00     9.57    16.40    3.85     11.91
2017-01-28 10:29:00    10.51    14.08    4.66     10.97
2017-02-04 10:29:00    10.43    16.69    4.53      6.09
2017-02-11 10:29:00    11.98    15.23    5.04     11.57

最后,通过可视化把不同周期的收盘价,画到一个图中。


> plot(d1$xdf.Close)
> lines(d7$xdf.Close,col='red',lwd=2)
> lines(m1$xdf.Close,col='blue',lwd=2)

从图中,可以看出切换为不同的周期,看到的形状是完全不一样的。黑色线表示以日为周期的,红色线表示以7日为周期的,蓝色线表示以月为周期的。

从本文的介绍来看,要做好数据处理是相当不容易的。你要知道数据是什么样的,业务逻辑是什么,怎么写程序以及数据变形,最后怎么进行BI展示,表达出正确的分析维度。试试R语言,忘掉程序员的思维,换成数据的思维,也许繁琐的数据处理工作会让你开心起来。

本文所介绍的数据处理的方法,及个性化的功能函数,我已经发布为一个github的开源项目,项目地址为:https://github.com/bsspirit/RTransform 欢迎大家试用,共同完善。

转载请注明出处:
http://blog.fens.me/r-transform/

打赏作者

新一代Node.js的Web开发框架Koa2

从零开始nodejs系列文章,将介绍如何利Javascript做为服务端脚本,通过Nodejs框架web开发。Nodejs框架是基于V8的引擎,是目前速度最快的Javascript引擎。chrome浏览器就基于V8,同时打开20-30个网页都很流畅。Nodejs标准的web开发框架Express,可以帮助我们迅速建立web站点,比起PHP的开发效率更高,而且学习曲线更低。非常适合小型网站,个性化网站,我们自己的Geek网站!!

关于作者:

  • 张丹(Conan), 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/nodejs-koa2

前言

Nodejs是一个年轻的编程框架,充满了活力和无限激情,一直都在保持着快速更新,甚至你都追不上他的更新速度。我写的“从零开始nodejs系列文章”,基本把Nodejs的应用领域都涵盖了,但是放下了1年半后,再重新用Nodejs做开发,发现都变了,还要再重新再学一遍。我花了3周的时间,重学了ES6, KOA2, VUE2, VUX, Angular2, Webpack等的框架,终于找回了之前用Nodejs的时候的一些感觉,所以就有了接来的一系列的文章,希望能把我的踩坑经验分享给大家。

本文标题为“新一代Node.js的Web开发框架Koa2”,那么上一代是什么呢?就是Express,我写过2篇文章来介绍Express的,请参考文章:Node.js开发框架Express4.xNodejs开发框架Express3.0开发手记–从零开始。同时,Koa也从Koa的1.x升级了Koa的2.x,一切都在加速,希望大家能够体会到加速世界,给开发带来的快感,这就是风口。

程序代码已经上传到github有需要的同学,自行下载。
https://github.com/bsspirit/koa2-sample

目录

  1. 安装Node环境
  2. 建立项目
  3. 通过koa-generator来建立项目
  4. 目录结构
  5. app.js 文件分析
  6. 路由管理
  7. 页面渲染
  8. 日志分析

1. 安装Node环境

让我们从头开始 Koa2 的安装和使用吧,第一步,就是安装Node和NPM环境。在Window上面安装,就直接从官方网站下载一个可执行安装文件,执行安装即可。

在Linux Ubuntu上安装过程也是类似,本机的系统环境为:Linux Ubuntu 16.04 LTS,然后下载Node工程的源文件,编译,安装。


# 切换到root用户
~ sudo -i      

# 下载nodejs最新版本,源代码       
~ wget https://nodejs.org/dist/v8.4.0/node-v8.4.0.tar.gz
~ tar xvzf node-v8.4.0.tar.gz
~ cd node-v8.4.0

 # 编译、安装
~ ./configure
~ make
~ make install

运行node命令和npm命令


~ node -v
v8.4.0

~ npm -v
5.4.1

2. 建立项目

下面我们就开始创建Koa2的项目,接下来的操作在window与linux通用,只是编辑器不同而已。

进入window的开发目录,新建项目koa2-demo1。


# 进入开发目录
~ cd d:\workspace\js

# 新建项目、并进入项目目录
~ mkdir koa2-demo1 && cd koa2-demo1

创建一个node项目


~ d:\workspace\js\koa2-demo1>npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install ` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
package name: (koa2-demo1)
version: (1.0.0)
description: koa2 demo
entry point: (index.js)
test command:
git repository:
keywords:
author: DanZhang
license: (ISC) MIT
About to write to d:\workspace\js\koa2-demo1\package.json:

{
  "name": "koa2-demo1",
  "version": "1.0.0",
  "description": "koa2 demo",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "DanZhang ",
  "license": "MIT"
}

Is this ok? (yes) yes

这样我们就完成了一个最简单的nodejs项目,在当前的目录下面生成了package.json的文件。

接下来,我们来安装koa2的库,到当前的项目中。


~ npm install koa -s
+ koa@2.3.0
added 37 packages in 12.462s

查看当前目录,发现生成了一个node_modules的目录,这个目录存放了koa包所有的依赖的库。

然后,我们新建一个启动文件:index.js,用来启动Koa的项目。


~ notepad index.js

var koa = require('koa');
var app = new koa();

app.use(function *(){
  this.body = 'Hello World';
});

app.listen(3000);

启动项目


~ node index.js

打开浏览器: http://localhost:3000/

看到这界面,那么恭喜你,第一步成功了。

3. 通过koa-generator来建立项目

Koa和Express项目一样,都提供了一种脚手架的方式来创建项目,使用这么方式会极大地提高开发的效率,但不建议初学者直接使用,高度自动化的生成器,可能会让你不理解实现的原理。

接下来,我们用koa-generator来生成一个koa的项目。

安装koa-generator,这是一个命令工具,所以需要全局安装。


~ npm install -g koa-generator

然后,我们创建koa2的项目时,就可以直接使用koa2的命令了。


# 进入开发目录
~ cd d:\workspace\js

# 生成koa2项目
~ koa2 koa2-demo2

   create : koa2-demo2
   create : koa2-demo2/package.json
   create : koa2-demo2/app.js
   create : koa2-demo2/public
   create : koa2-demo2/public/stylesheets
   create : koa2-demo2/public/stylesheets/style.css
   create : koa2-demo2/public/javascripts
   create : koa2-demo2/public/images
   create : koa2-demo2/routes
   create : koa2-demo2/routes/index.js
   create : koa2-demo2/routes/users.js
   create : koa2-demo2/views
   create : koa2-demo2/views/index.pug
   create : koa2-demo2/views/layout.pug
   create : koa2-demo2/views/error.pug
   create : koa2-demo2/bin
   create : koa2-demo2/bin/www

   install dependencies:
     > cd koa2-demo2 && npm install

   run the app:
     > SET DEBUG=koa* & npm start koa2-demo2

进入项目,并安装依赖库


~ cd koa2-demo2 && npm install

启动项目


~ npm run start

> koa2-demo2@0.1.0 start d:\workspace\js\koa2-demo2
> node bin/www

打开浏览器

如果你看到的界面,和上面的一样,那么恭喜你,用koa-generator生成的koa2的项目,也能正常工作了。这里你可以发现,用koa-generator时,只要一条命令就够了,程序会给你生成很多文件,直接就构建好了一个项目的基础。

4. 目录结构

接下来,我们就基于koa2-demo2的项目来分析,看一下生成出来的项目目录结构。我们用一个文本编辑器来打开这个项目,这样可以看得更清楚一些。

  • bin, 存放启动项目的脚本文件
  • node_modules, 存放所有的项目依赖库。
  • public,静态文件(css,js,img)
  • routes,路由文件(MVC中的C,controller)
  • views,页面文件(pug模板)
  • package.json,项目依赖配置及开发者信息
  • app.js,应用核心配置文件
  • package.json,node项目配置文件
  • package-lock.json,node项目锁定的配置文件

5. app.js 文件分析

app.js 是应用核心配置文件,我们把这个文件能够看明白,整理koa就非常容易了。

app.js文件,我们可以分割为X个部分进行解读:依赖包加载、错误处理、中间件加载、web界面渲染模板、自定义日志、自己定义路由、外部调用接口。


// 依赖包加载
const Koa = require('koa')
const app = new Koa()
const views = require('koa-views')
const json = require('koa-json')
const onerror = require('koa-onerror')
const bodyparser = require('koa-bodyparser')
const logger = require('koa-logger')

const index = require('./routes/index')
const users = require('./routes/users')

// 错误处理
onerror(app)

// 中间件加载
app.use(bodyparser({
  enableTypes:['json', 'form', 'text']
}))
app.use(json())
app.use(logger())
app.use(require('koa-static')(__dirname + '/public'))

// web界面渲染模板
app.use(views(__dirname + '/views', {
  extension: 'pug'
}))

// 自定义日志
app.use(async (ctx, next) => {
  const start = new Date()
  await next()
  const ms = new Date() - start
  console.log(`${ctx.method} ${ctx.url} - ${ms}ms`)
})

// 自己定义路由
app.use(index.routes(), index.allowedMethods())
app.use(users.routes(), users.allowedMethods())

// 外部调用接口
module.exports = app

麻雀虽小,五脏俱全!通过app.js的配置,就可以把一个web项目给组装起来了。

6. 路由管理

普通的web应用,通常都是多个页面组成,每个页面会对应一个URL的地址,用户在浏览器输入URL可以打开不同的页面。路由管理,就是把URL和页面的关系对应起来的。

在 app.js 中,路由来提取到 ./routes/index.js 和 ./routes/users.js 两个文件中进行实现了。

以 ./routes/index.js 文件来举例说明。


~ notepad ./routes/index.js

const router = require('koa-router')()

// 解析'/'
router.get('/', async (ctx, next) => {  
  await ctx.render('index', {
    title: 'Hello Koa 2!'
  })
})

// 解析 '/string'
router.get('/string', async (ctx, next) => {
  ctx.body = 'koa2 string'
})

// 解析 '/json'
router.get('/json', async (ctx, next) => {
  ctx.body = {
    title: 'koa2 json'
  }
})

module.exports = router

从代码中分析,当路径为’/’时,网页会返回Hello Koa 2!;当路径为’/string’时,网页会返回koa2 string;哪路径是/json时,网页会返回koa2 json。

7. 页面渲染

从上面路由中,我们看到路径’/’的输出,是一个被渲染为网页输出,而’/string’和’/json’的输出是直接字符的输出。传统的web应用,大都是后台渲染的机制。新型的单面应用来说,前后端分离的设计,根本不需要后端来渲染,直接输出json就可以了。

对后台渲染的实现,我们可以参考’/’的实现。


router.get('/', async (ctx, next) => {
  await ctx.render('index', {
    title: 'Hello Koa 2!'
  })
})

上面代码中,通过 await ctx.render(‘index’,{}) 这样的语法,就可以加载pug的模板引擎。

  • await是ES6的关键字,用于把异步代码同步化,就不再写回调函数了(callback)。
  • ctx.render()函数,用于加载渲染引擎。

然后,我们找到views中的index.pug文件。


~ notepad ./views/index.pug

extends layout

block content
  h1= title
  p Welcome to #{title}

在index.pug文件中,有一个参数是后台传过来的,就是title,同时index.pug继承了layout.pug。

再打开layout.pug文件。


doctype html
html
  head
    title= title
    link(rel='stylesheet', href='/stylesheets/style.css')
  body
    block content

layout.pug文件,是整个html的骨架,这样就可以通过后台要渲染为一个HTML的网页了。打开chrome浏览品质开发人员工具,看到HTML的代码的结构,与layout.pug和index.pug结构是一致的。

8. 日志分析

最后要说的就是服务器日志了,每一次的浏览行为,都会产生一条服务器日志,用于记录用户的访问情况。我们后台通过命令行启动后,后台的服务器就会一直存活着,接收浏览器的请求,同时产生日志。

日志中,200表示正常访问,404是没有对应的URL错误。你会看到每次访问的路径都被记录了,包括后台的路径和css的文件路径,还包括了访问协议,响应时间,页面大小等。

我们可以自定义日志格式,记录更多的信息,也可以记录对自己有用的信息。这样我们就构建出一个最小化的web应用了。

Nodejs的发展速度,远远超越了其他语言的发展,我看好Nodejs,希望能给入门Nodejs的朋友一些帮助。加油!!

程序代码已经上传到github有需要的同学,自行下载。
https://github.com/bsspirit/koa2-sample

转载请注明出处:
http://blog.fens.me/nodejs-koa2

打赏作者

在Ubuntu上安装IPSEC VPN服务

操作系统实用工具系列文章,将介绍基于Linux ubuntu的各种工具软件的配置和使用。有些工具大家早已耳熟能详,有些工具经常用到但确依然陌生。我将记录我在使用操作系统时,安装及配置工具上面的一些方法,把使用心得记录下来也便于自己的以后查找和回忆。

关于作者:

  • 张丹(Conan), 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/ubuntu-vpn-ipsec

前言

随着iphone的IOS版本升级到了10以后,PPTP协议的VPN不再支持了。为了能够继续使用Google的服务,提升对信息的准确查询,那么只能基于新的标准,再重新搭建一套的环境。用PPTP搭建VPN请参考文章:在Ubuntu上安装PPTP VPN服务

本文只是在纯技术层面进行介绍,如何使用IPSEC协议来搭建VPN服务。

目录

  1. IPSEC协议
  2. 服务器端程序搭建
  3. 客户端测试
  4. 剖析脚本

1. IPSEC协议

IPSec(Internet Protocol Security)是一种开放标准的框架结构,通过使用加密的安全服务以确保在 Internet 协议 (IP) 网络上进行保密而安全的通讯。它通过端对端的安全性来提供主动的保护以防止专用网络与 Internet 的攻击。在通信中,只有发送方和接收方才是唯一必须了解 IPSec 保护的计算机。

IPSEC包封装过程

我们有一个生活中简单的例子,来说明一下IPSEC包封装过程。

假设2个小朋友A和B要邮寄包裹,A要寄东西给B,A的爸爸和B的爸爸正巧在一家公司工作,所以A就把给B的包裹,交给了A的爸爸,再由A的爸爸转交给B的爸爸,B的爸爸最后把包裹给B的手中。回寄也一样,通过B的父亲发回给A的父亲再回给A。

这种通讯实现方式要依赖以下几个因素:

  • A的爸爸和B的爸爸可以见到。
  • A发包裹,把包裹交给A的爸爸。
  • A的爸爸收到儿子的包裹后,能够正确的处理,并且重新包装过的包裹能够正确送出去。
  • 另外一端,B的爸爸收到包裹开以后,能够正确地交给B。
  • 反过来的流程一样。

2. 服务器端程序搭建

本来安装和配置IPSEC服务,不是一件容易,但无意中发现了 IPsec VPN 服务器一键安装脚本 项目,让这一切都变得非常简单。感谢项目作者 Lin Song

我的服务器环境是Ubuntu 16.04 LTS,主机在香港。

一键安装,只需要3个步骤。

  1. 从网上下载一个shell脚步。
  2. 修改登录的用户名、密码、秘钥。
  3. 运行脚本

1. 从网上下载一个shell脚步。


~ wget https://git.io/vpnsetup -O vpnsetup.sh

2. 修改登录的用户名、密码、秘钥。


~ vi vpnsetup.sh

# Define your own values for these variables
# - IPsec pre-shared key, VPN username and password
# - All values MUST be placed inside 'single quotes'
# - DO NOT use these characters within values:  \ " '
    
YOUR_IPSEC_PSK='abc'       # 设置密钥
YOUR_USERNAME='conan'      # 设置用户名
YOUR_PASSWORD='12345678'   # 设置密码

# 省略...

3. 运行脚本


~ sudo sh vpnsetup.sh

3. 客户端测试

我的iphone-7手机,OS的版本为10.3.3,打开VPN的设置界面。设置–>通用–>VPN–>添加VPN配置。

具体配置

测试VPN是否正常工作,打开浏览器,访问www.google.com网页。

如果你也看到google,那么恭喜你就配置成功了!!

4. 剖析脚本

通过上面的操作,我们已经完成了VPN服务器的搭建,那么为什么还要有剖析脚本这个部分呢。我本来也自己尝试着参考网上的一些文章,以及一些开源VPN服务器的说明去配置,但花了几天的时间,一直都没有完全调通。这里其实有不少的网络知识点,是需要我们理解和掌握的。

正好可以查看 vpnsetup.sh 文件,一步一步的分析。

4.1 安装依赖包。


// 更新源
~ apt-get update

// 基础工具包
~ apt-get -yq install wget dnsutils openssl 
~ apt-get -yq install iproute gawk grep sed net-tools

// VPN相关的包
~ apt-get -yq install libnss3-dev libnspr4-dev pkg-config libpam0g-dev \
  libcap-ng-dev libcap-ng-utils libselinux1-dev \
  libcurl4-nss-dev flex bison gcc make \
  libunbound-dev libnss3-tools libevent-dev 
~ apt-get -yq --no-install-recommends install xmlto 
~ apt-get -yq install ppp xl2tpd 

// SSH相关的包
~ apt-get -yq install fail2ban
~ apt-get -yq install libsystemd-dev 

4.2 下载及安装libreswan包


~ wget https://download.libreswan.org/libreswan-3.21.tar.gz
~ tar xzf libreswan-3.21.tar.gz && cd libreswan-3.21
~ make -s programs && make -s install

4.3 修改配置文件

  • /etc/ipsec.conf
  • /etc/ipsec.secrets
  • /etc/xl2tpd/xl2tpd.conf
  • /etc/ppp/options.xl2tpd
  • /etc/ppp/chap-secrets
  • /etc/ipsec.d/passwd
  • /etc/sysctl.conf
  • /etc/iptables.rules

4.3.1 查看/etc/ipsec.conf


~ vi /etc/ipsec.conf

version 2.0

config setup
  virtual_private=%v4:10.0.0.0/8,%v4:192.168.0.0/16,%v4:172.16.0.0/12,%v4:!192.168.42.0/24,%v4:!192.168.43.0/24
  protostack=netkey
  nhelpers=0
  interfaces=%defaultroute
  uniqueids=no

conn shared
  left=%defaultroute
  leftid=123.123.123.123   # 当前服务器的IP
  right=%any
  encapsulation=yes
  authby=secret
  pfs=no
  rekey=no
  keyingtries=5
  dpddelay=30
  dpdtimeout=120
  dpdaction=clear
  ike=3des-sha1,3des-sha2,aes-sha1,aes-sha1;modp1024,aes-sha2,aes-sha2;modp1024,aes256-sha2_512
  phase2alg=3des-sha1,3des-sha2,aes-sha1,aes-sha2,aes256-sha2_512
  sha2-truncbug=yes

conn l2tp-psk
  auto=add
  leftprotoport=17/1701
  rightprotoport=17/%any
  type=transport
  phase2=esp
  also=shared

conn xauth-psk
  auto=add
  leftsubnet=0.0.0.0/0
  rightaddresspool=192.168.43.10-192.168.43.250
  modecfgdns1=8.8.8.8               # DNS 解析1
  modecfgdns2=8.8.4.4               # DNS 解析2
  leftxauthserver=yes
  rightxauthclient=yes
  leftmodecfgserver=yes
  rightmodecfgclient=yes
  modecfgpull=yes
  xauthby=file
  ike-frag=yes
  ikev2=never
  cisco-unity=yes
  also=shared
                   

4.3.2 查看/etc/ipsec.secrets


~ vi /etc/ipsec.secrets

%any  %any  : PSK "abc"                    # 设置ipsec的登录权限,秘钥为abc

4.3.3 查看/etc/xl2tpd/xl2tpd.conf


~ vi /etc/xl2tpd/xl2tpd.conf

[global]
port = 1701                                 # 连接端口

[lns default]
ip range = 192.168.42.10-192.168.42.250     # VPN内网IP段
local ip = 192.168.42.1                     # 主机的内网IP
require chap = yes                          # 要求chap身份认证模式
refuse pap = yes                            # 拒绝pap身份认证模式
require authentication = yes                # 要求认证登录
name = l2tpd                                # 服务名称为l2tpd
pppoptfile = /etc/ppp/options.xl2tpd        # ppp的配置文件
length bit = yes

4.3.4 查看/etc/ppp/options.xl2tpd


~ vi /etc/ppp/options.xl2tpd

ipcp-accept-local
ipcp-accept-remote
ms-dns 8.8.8.8                  # DNS 解析1
ms-dns 8.8.4.4                  # DNS 解析2
noccp
auth
mtu 1280
mru 1280
proxyarp                        # arp代理
lcp-echo-failure 4
lcp-echo-interval 30
connect-delay 5000

4.3.5 查看 /etc/ppp/chap-secrets


~ vi /etc/ppp/chap-secrets

# Secrets for authentication using CHAP
# client  server  secret  IP addresses
# 用户名  服务类型   密码   分配的ip地址
"conan" l2tpd "12345678" *                          # 设置客户端登录账户和密码,4个字段用空格分隔, *表示任意类型

4.3.6 查看 /etc/ipsec.d/passwd


~ vi  /etc/ipsec.d/passwd

conan:$1$rkrg5ssz$3lTGfeeazreqrR79pAoggh1:xauth-psk    # 使用秘钥加密后的密码

4.3.7 查看 /etc/sysctl.conf


~ vi /etc/sysctl.conf

kernel.msgmnb = 65536
kernel.msgmax = 65536
kernel.shmmax = 68719476736
kernel.shmall = 4294967296

net.ipv4.ip_forward = 1
net.ipv4.tcp_syncookies = 1
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.lo.send_redirects = 0
net.ipv4.conf.eth0.send_redirects = 0
net.ipv4.conf.all.rp_filter = 0
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.lo.rp_filter = 0
net.ipv4.conf.eth0.rp_filter = 0
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.icmp_ignore_bogus_error_responses = 1

net.core.wmem_max = 12582912
net.core.rmem_max = 12582912
net.ipv4.tcp_rmem = 10240 87380 12582912
net.ipv4.tcp_wmem = 10240 87380 12582912

4.3.8 查看/etc/iptables.rules


~ vi /etc/iptables.rules

# Modified by hwdsl2 VPN script
# Generated by iptables-save v1.6.0 on Mon Sep 18 22:36:46 2017
*nat
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 192.168.42.0/24 -o eth0 -j MASQUERADE
-A POSTROUTING -s 192.168.43.0/24 -o eth0 -m policy --dir out --pol none -j MASQUERADE
COMMIT
# Completed on Mon Sep 18 22:36:46 2017
# Generated by iptables-save v1.6.0 on Mon Sep 18 22:36:46 2017
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -p udp -m udp --dport 1701 -m policy --dir in --pol none -j DROP
-A INPUT -m conntrack --ctstate INVALID -j DROP
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -p udp -m multiport --dports 500,4500 -j ACCEPT
-A INPUT -p udp -m udp --dport 1701 -m policy --dir in --pol ipsec -j ACCEPT
-A INPUT -p udp -m udp --dport 1701 -j DROP
-A FORWARD -m conntrack --ctstate INVALID -j DROP
-A FORWARD -i eth0 -o ppp+ -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i ppp+ -o eth0 -j ACCEPT
-A FORWARD -s 192.168.42.0/24 -d 192.168.42.0/24 -i ppp+ -o ppp+ -j ACCEPT
-A FORWARD -d 192.168.43.0/24 -i eth0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -s 192.168.43.0/24 -o eth0 -j ACCEPT
-A FORWARD -s 10.1.20.0/24 -j ACCEPT
-A FORWARD -j DROP
COMMIT
# Completed on Mon Sep 18 22:36:46 2017

4.4 查看连接日志

接下来,我们用手机连接VPN,然后查看日志输出 。

连接日志


~ tail -f /var/log/syslog

Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: Connection established to 36.102.226.172, 65287.  Local: 21666, Remote: 20 (ref=0/0).  LNS session is 'default'
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: start_pppd: I'm running:
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "/usr/sbin/pppd"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "passive"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "nodetach"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "192.168.42.1:192.168.42.10"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "refuse-pap"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "auth"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "require-chap"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "name"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "l2tpd"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "file"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "/etc/ppp/options.xl2tpd"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "plugin"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "pppol2tp.so"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "pppol2tp"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "8"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "pppol2tp_lns_mode"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "pppol2tp_tunnel_id"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "21666"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "pppol2tp_session_id"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: "21136"
Sep 19 13:54:28 i-vtnhoxsp xl2tpd[20115]: Call established with 36.102.226.172, Local: 21136, Remote: 10537, Serial: 1
Sep 19 13:54:28 i-vtnhoxsp pppd[23553]: Plugin pppol2tp.so loaded.
Sep 19 13:54:28 i-vtnhoxsp pppd[23553]: pppd 2.4.7 started by root, uid 0
Sep 19 13:54:28 i-vtnhoxsp pppd[23553]: Using interface ppp0
Sep 19 13:54:28 i-vtnhoxsp pppd[23553]: Connect: ppp0 <-->
Sep 19 13:54:28 i-vtnhoxsp pppd[23553]: Overriding mtu 1500 to 1280
Sep 19 13:54:28 i-vtnhoxsp pppd[23553]: Overriding mru 1500 to mtu value 1280
Sep 19 13:54:28 i-vtnhoxsp pppd[23553]: Overriding mtu 1500 to 1280
Sep 19 13:54:32 i-vtnhoxsp charon: 05[KNL] 192.168.42.1 appeared on ppp0
Sep 19 13:54:32 i-vtnhoxsp charon: 03[KNL] 192.168.42.1 disappeared from ppp0
Sep 19 13:54:32 i-vtnhoxsp charon: 07[KNL] 192.168.42.1 appeared on ppp0
Sep 19 13:54:32 i-vtnhoxsp pppd[23553]: Cannot determine ethernet address for proxy ARP
Sep 19 13:54:32 i-vtnhoxsp pppd[23553]: local  IP address 192.168.42.1
Sep 19 13:54:32 i-vtnhoxsp pppd[23553]: remote IP address 192.168.42.10
Sep 19 13:54:32 i-vtnhoxsp charon: 10[KNL] interface ppp0 activated

断开手机的VPN连接,查看日志。


~ tail -f /var/log/syslog

Sep 19 13:55:53 i-vtnhoxsp xl2tpd[20115]: result_code_avp: result code endianness fix for buggy Apple client. network=768, le=3
Sep 19 13:55:53 i-vtnhoxsp xl2tpd[20115]: control_finish: Connection closed to 36.102.226.172, serial 1 ()
Sep 19 13:55:53 i-vtnhoxsp pppd[23553]: LCP terminated by peer (User request)
Sep 19 13:55:53 i-vtnhoxsp xl2tpd[20115]: Terminating pppd: sending TERM signal to pid 23553
Sep 19 13:55:53 i-vtnhoxsp pppd[23553]: Connect time 1.4 minutes.
Sep 19 13:55:53 i-vtnhoxsp pppd[23553]: Sent 93199 bytes, received 34500 bytes.
Sep 19 13:55:53 i-vtnhoxsp charon: 06[KNL] interface ppp0 deactivated
Sep 19 13:55:53 i-vtnhoxsp xl2tpd[20115]: result_code_avp: result code endianness fix for buggy Apple client. network=256, le=1
Sep 19 13:55:53 i-vtnhoxsp xl2tpd[20115]: control_finish: Connection closed to 36.102.226.172, port 65287 (), Local: 21666, Remote: 20
Sep 19 13:55:53 i-vtnhoxsp charon: 03[KNL] 192.168.42.1 disappeared from ppp0
Sep 19 13:55:53 i-vtnhoxsp pppd[23553]: Overriding mtu 1500 to 1280
Sep 19 13:55:53 i-vtnhoxsp pppd[23553]: Overriding mru 1500 to mtu value 1280
Sep 19 13:55:53 i-vtnhoxsp pppd[23553]: Terminating on signal 15
Sep 19 13:55:56 i-vtnhoxsp pppd[23553]: Connection terminated.
Sep 19 13:55:56 i-vtnhoxsp charon: 11[KNL] interface ppp0 deleted
Sep 19 13:55:56 i-vtnhoxsp pppd[23553]: Modem hangup
Sep 19 13:55:56 i-vtnhoxsp pppd[23553]: Exit.

对于脚本的分析,虽然没有给出结论,而且很多配置我还是不太理解。不过要坚持学习,不断的提升自己的能力,不然永远都要等着大牛们提供一键安装的脚本。

转载请注明出处:
http://blog.fens.me/ubuntu-vpn-ipsec

打赏作者

2017CDAS中国数据分析师行业峰会:用R语言解读股利贴现模型

跨界知识聚会系列文章,“知识是用来分享和传承的”,各种会议、论坛、沙龙都是分享知识的绝佳场所。我也有幸作为演讲嘉宾参加了一些国内的大型会议,向大家展示我所做的一些成果。从听众到演讲感觉是不一样的,把知识分享出来,你才能收获更多。

关于作者:

  • 张丹(Conan), 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/meeting-cdas-20170729

前言

今年的数据分析师大会,国贸,中国大饭店,高规格,上档次!虽然只有1天,却吸引了3000+人的报名参会。11个分会场都是从数据角度来切入,包括了 大数据与生物医疗,大数据与云计算,互联网大数据,电商大数据,大数据与金融,大数据与人工智能,数据可视化与商业BI,大数据与交通旅游,大数据与智慧投资,数据库技术与实战,CDA数据分析师专场。

我的分享在 大数据与金融专场,见到了很多熟悉的朋友,同时也认识不少的新朋友。希望大家能够学到知识,并真正地落地到实际的工作中来。

我已经连续参加了3年的CDAS中国数据分析师行业峰会,祝这个数据的大会越办越好。前2年数据分析师大会会议纪要:2016数据分析师大会2015数据分析师大会

目录

  1. 我的演讲主题:用R语言解读股利贴现模型
  2. 会议体验和照片分享

1. 我的演讲主题:用R语言解读股利贴现模型

用R语言解读股利贴现模型,PPT下载,主要内容来自我的一篇博文:用R语言解读股利贴现模型(未发布)

本次分享我详细讲述了,股利贴现模型的原理和方法,并用这个模型分析招商银行(600036.SH)股票,最后用程序来实现。如果你按照我的思路去操作,相信也能很快找到被低估的股票,从而赚到靠能力可以赚到的钱。

本次分享的目录:

  1. 发现错误的定价
  2. 股利贴现模型
  3. 投资机会
  4. A股市场案例分析
  5. 用R语言实现

为了本次的分享,我花了2周的时间进行准备。希望能够给大家分享一个,实用的模型,这样听完了就可以回去动手实验了。由于分享时间比较短,而且又有不少的金融专业知识,要在30分内给大家讲一个新东西,确实很难啊,我也是挑战了一下自己。

我一直延续了一贯的演讲风格,有内容,有图片,有代码,有互动。从方法理论的思路开始,到市场特征检验,再到数学公式,R语言建模,把知识和市场操作联系起来,听完我的分享,你回去把上就可以动手实践。利用IT人的技术优势,可以真正地与实际操作结合起来,实现从IT技术到价值的转变。

2. 会议体验和照片分享

这次的大会虽然只有1天,也能看出来主办方准备充分。不得不说一句,所有的工作人员辛苦了!

“跨界互联,数聚未来”是本次会议的主题,会议主页:http://cdas.cda.cn/。以数据为题,研习技术,比拼创意,交流思想,探寻未来,打造一场大数据与大思维的盛筵。

2.1 大数据与金融场,我是第4位分享嘉宾。

  • 李峰,IBM Analytics LBS首席数据科学家,主题:人工智能助力银行审计管理
  • 于晓松,诸葛io产品VP,主题:深入金融场景的数据驱动与应用
  • 郑志勇,集思录副总裁,主题:资产配置与数据分析
  • 张丹,《R的极客理想》系列图书作者,主题:用R语言实现量化交易策略
  • 雷涛,天云大数据CEO,主题:Fintech实践:从BI到AI的演进路径
  • 赵刚,北京赛智时代信息技术咨询有限公司CEO,主题:“双创”大数据金融分析服务

我在分享的照片

其他嘉宾的照片

李峰

于晓松

郑志勇

金融会场照片

2.2 会议相关照片

大会开幕式

精彩瞬间

工作人员

最后,感谢CDAS工作人员的辛苦劳动,希望保持高水平会议越办越好!

转载请注明出处:
http://blog.fens.me/meeting-cdas-20170729

打赏作者

2017微软MVP:在AWS上部署免费的Shiny应用

跨界知识聚会系列文章,“知识是用来分享和传承的”,各种会议、论坛、沙龙都是分享知识的绝佳场所。我也有幸作为演讲嘉宾参加了一些国内的大型会议,向大家展示我所做的一些成果。从听众到演讲感觉是不一样的,把知识分享出来,你才能收获更多。

关于作者

  • 张丹, 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog:http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/meeting-mvp-20170723

前言

第一次参加微软的技术日活动,感觉微软已经变得开放了,已不是10年前我所印象的对开源很敌对的微软了。在微软的会场,我主要介绍的是开源技术R语言。

本次的我的主题是AWS和Shiny,Shiny是R语言中一个“神级”的,绝对是好东西;而AWS为全球的开发者提供了免费的服务器,值得赞赏。把这两个好的东西结合在一起,就是一个很好的业务模式,可以极大的帮助个人开发者,来发布自己的作品或产品。

本次所分享的内容为一个实战案例,你可以跟着我的操作,重现我所讲的总有内容。错过沙龙的同学,也可以在天善社区的网站上找到分享的内容。

目录

  1. 我的演讲主题:在AWS上部署免费的Shiny应用
  2. 会议体验和照片分享

1. 我的演讲主题:在AWS上部署免费的Shiny应用

在AWS上部署免费的Shiny应用,PPT下载,主要内容来自我的一篇博文:在AWS上部署免费的Shiny应用

分享主题的目录大纲如下:

  1. Shiny是什么?
  2. 本地开发一个Shiny小应用
  3. 申请AWS免费服务器
  4. 在AWS上安装R语言环境
  5. 在AWS上安装Shiny Server
  6. 在AWS上部署自己的Shiny应用
  7. 番外篇

前6个目录都是正常的技术,番外篇,其实是比较有意思的一个内容。原本我是准备把一个基于赌场原型的Shiny应用放到互联网,考虑服务器位置和选型的问题,无意中发现了AWS的免费资源,这样就有了这样的一篇Shiny与AWS结合的文章。

提问环节时,同学们很热列问了不少的R和Shiny的问题。真的希望大家,动手试一下,R语言一定会给你很棒的体验的。

分享结束后,和几位现场的朋友,聊了中国市场环境与发展机会。感觉到各行各业的人,都体会到了大数据所带来的变化,准备进行大数据的市场,获得更多的商业机会。我觉得中国是有大数据土壤的,而且环境在变好,有越来越多的机会,给留我们去创新和发展。

同时,我也在致力于推动R语言在中国金融领域的发展,让R可以给更多的用户使用,培养出更多的数据分析师。也希望让我们中国人的技术能够走出去到世界的舞台。希望多能认识志同道合的朋友,一起做一些事情。

2. 会议体验和照片分享

本次由5个主题组成,主要是微软的产品技术介绍,毕竟是在人家的主场。

本次微软MVP参加分享的5位嘉宾,主持人 和 微软MVP项目负责人介绍:

吕品,活动介绍 & 现场主持
天善智能联合创始人,微软MVP

Christina,主题:微软项目介绍
China MVP Community Manager

张丹,主题:在AWS上部署免费的Shiny应用,PPT下载
《R的极客理想》系列图书作者,前况客创始人兼CTO。12年IT编程背景,精通R ,Java, Nodejs 编程,获得10项SUN及IBM技术认证。著有《R的极客理想-工具篇》、《R的极客理想-高级开发篇》,合著《数据实践之美》,新书《R的极客理想-量化投资篇》。

刘凯,主题:PowerBI高阶分析:高阶预测分析;DAX万能组合函数的高级应用
IMA中国教育委员会认证讲师,擅长业财融合背景下的数据整合和运营财务分析。曾任职于4A的奥美互动咨询和四大中的KPMG毕博管理咨询,服务于海尔金控等多家客户。

宋卫东,主题:数据仓库运维那些事
从事商业智能数据仓库方向11年,就职某汽车公司,负责数据仓库和大数据等项目。

李奇,主题:Excel BI:无所不能的业务数据分析利器
中国电子表格应用大会主席、曾任职于IBM及德勤会计师事务所,从事业务分析及数据分析咨询工作,Excel BI培训讲师、擅长用Excel创建商业智能报表。

宋沄剑,主题:亿级SQL Server运维的n个最佳实践,PPT下载
微软DataPlatform MVP(since 2012),目前就职于易车网,负责易车数据库与基于Apache生态圈的大数据平台的运维。曾任数据库高级顾问,帮助国内多家客户设计高可用/灾备方案,监控方案、运维自动化方案,并处理SQL Server企业应用实施、日常管理中常见的棘手问题。曾翻译包括SQLServer、PowerShell、Python在内的多本技术书籍,个人技术博客在国内最大的微软社区排名考前,曾多次在数据库大会、Teched、Ignite上分享经验。

嘉宾在分享的照片。

张丹

刘凯

李奇

Christina

宋卫东

宋沄剑

2.2 会议相关照片

本次的场地在微软的北京研发中心,忍不住要说会场很棒,不差钱就是好,干净、整齐、大方。

现场照片

大合照

沙龙很成功,感谢天善社区的工作人员,微软主办方的工作人员,IT大咖说直播的工作人员,大家都辛苦了!祝高质的沙龙,在北京越办越好,让无数有理想的年轻人,能开阔眼界,了解行业动态,推动知识的进步。

转载请注明出处:
http://blog.fens.me/meeting-mvp-20170723

打赏作者