Jimmy那些事儿

R_日期处理_lubridate

发表 | 更新 | 分类 ， ， | 阅读次数

R_日期处理_lubridate

基本概念

时间概念

UTC：（英文“Coordinated Universal Time”／法文“Temps Universel Coordonné”），协调世界时，又称世界标准时间或世界协调时间

  • 最主要的世界时间标准，其以 [原子时] 秒长为基础，在时刻上尽量接近于格林尼治标准时间。
  • 协调世界时把时间分为天、小时、分钟和秒

格林威治标准时间；英语：Greenwich Mean Time，GMT）是指位于英国伦敦郊区的皇家格林尼治天文台当地的标准时间，因为本初子午线被定义为通过那里的经线。

  • 理论上来说，格林尼治标准时间的正午是指当太阳横穿格林尼治子午线时（也就是在格林尼治上空最高点时）的时间。但由于地球在它的椭圆轨道里的运动速度不均匀，这个时刻可能与实际的太阳时有误差，最大误差达16分钟。原因在于地球每天的自转是有些不规则的，而且正在缓慢减速，因此格林尼治时间基于天文观测本身的缺陷，已经不再被作为标准时间使用。
  • 现在的标准时间，是由 [原子钟] 报时的协调世界时（UTC）来决定。


R语言中的时间

R语言的基础包中提供了两种类型的时间数据

  1. Date类型，仅包括日期数据，它不包括时间和时区信息
  2. POSIXct / POSIXlt 类型，其中包括了日期、时间和时区信息。

日期-时间=不可运算

默认情况下，日期是以/或者-进行分隔，而时间则以:进行分隔；


POSIXct / POSIXlt / strptime 的区别

  • POSXIct ：它存储自UNIX纪元(+其他数据)以来的秒数 ；用数字表示，一个较大的整数，可以存储到数据框中
  • POSIXlt ：日期时间类，精确到秒，用列表表示，可以更精确地存储日/月/年/小时/分钟/秒等

函数运行 - POSIXlt

  • strptime ：字符向量(各种格式)直接转换为POSIXlt格式的函数
  • as.POSIXlt：将各种数据类型转换为POSIXlt。

函数运行 - POSIXct

  • as.POSIXct：将各种数据类型转换为POSIXct。
    • 它首先运行strptime，然后从POSIXlt到POSIXct的转换
  • parse_date_time：将各种类型的数据转为为POSIXct


lubridate包主要有两类函数：

  1. 处理时点数据（time instants）
  2. 处理时段数据（time spans）


时点类


解析与提取日期 - Prasing

解析日期， year(x)

设定日期，通过赋值进行设定 year(x) <- value


解析与转化

解析日期：解析并转化格式

  • ymd(“…”, tz=NULL) / dmy() / mdy() ：处理不同顺序的日期数据，使之按年月日的形式排列
    • dym() / ydm()

tz = NULL； 或为 指定的时区

locale = Sys.getlocale(“LC_TIME”) ：默认；

1
2
3
4
5
6
7
8
9
# 处理日期，使之按年月日的形式排列
> mdy("06-04-2011")
[1] "2011-06-04"
> dmy("04/06/2011")
[1] "2011-06-04"
ymd('20170208')
[1] "2017-02-08"
  • hms(“…”, roll=FALSE) / hm() / ms() ：处理不同顺序的时间数据

roll=FALSE 默认；若为TRUE，则根据规则进行换算

1
2
3
4
5
6
7
8
9
10
11
12
# 处理时间
> hms("14:20:01")
[1] "14H 20M 1S"
> hms("01:59:120")
[1] "1H 59M 120S"
> hms("01:59:120",roll=T)  # roll=T,进行换算
[1] "2H 1M 0S"
ymd_hms("20161120220000")
[1] "2016-11-20 22:00:00 UTC"
  • ymd_hms(“…”, tz=”UTC”, locale=Sys.getlocale(“LC_TIME”), truncated = 0) / ymd_hm / ymd_h ：处理不同顺序的日期时间数据
    • dmy_hms /dmy_hm /dmy_h
    • mdy_hms / mdy_hm / mdy_h

… : 一个字符串向量 in year, month, day, hour, minute, second format

tz =”UTC” ：世界标准时间


提取部分值 - 单一

  • year(“”) / month() / week() / day() / hour() / minute() / second() ：解析日期中的部分值
  • month(x, label=FALSE, abbr=TRUE)

label= FALSE，默认；将月份作为数值进行显示；若为TRUE，则作为字符串 “January.”

abbr = TRUE，默认，将月份作为字符串的缩写进行显示”Jan”，当label为FALSE时忽略该参数；若为FALSE，则显示全称 “January.”； (abbreviate ：缩写)

  • yday(x)：一年中的第几天
  • mday(x)：一个月中的第几天
  • wday(x)：一周中的星期几 [1, 7]
  • qday(x)：一个季度中的第几天
  • days_in_month() ：返回所属月份的最大天数
  • am(x) / pm(x) ：返回逻辑值，判断是否为上午/下午
    • 12:00:00 判断为下午；am(hms('11:59:59')) [1] TRUE am(hms('12:00:00')) [1] FALSE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> year('2017-01-02')
[1] 2017
> month('2017-01-02')
[1] 1
> month('2017-01-02', label=T)
[1] Jan
## 设定日期-----------------------------
> x <- ymd('2010-04-08');  x
[1] "2010-04-08"
> month(x) <- 5  ; x
[1] "2010-05-08"
> days_in_month(as.Date('2017-05-10'))
May 
 31


转换

时区的概念很重要

  • 用 ymd_hms / as_datetime 创建的时区为 UTC
  • 用as.POSIXct / as.POSIXlt 创你的时区为 CST

CST应该是指（China Shanghai Time，东八区时间）
UTC应该是指（Coordinated Universal Time，标准时间）
所以，这2个时间实际上应该相差8个小时。

  • 使用解析函数进行转换 ymd / ymd_hms 
1
2
3
4
5
6
7
8
9
> class(ymd("2017-05-21"))
[1] "Date"
> ymd_hms("2017-04-21 00:09:21") %>% class()
[1] "POSIXct" "POSIXt" 
# 默认时区为UTC
> ymd_hms("2017-04-21 00:09:21")
[1] "2017-04-21 00:09:21 UTC"
  • as_date() ：转化为日期格式的数据

format = “ “ 指定转化后的日期格式

  • as_datetime() ：转化为日期+时间格式的数据
    • 若字符串转为日期+时间格时，若使用as_datetime 时间上会出错，应使用解析函数 或 parse_date_time
    • 原因在于默认的时区为 UTC，而非CST
1
2
3
4
5
> as_date("2017-08-14 10:01:00 CST")
[1] "2017-08-14"
> as_datetime("2017-08-14 10:01:00 CST")
[1] "2017-08-14 02:01:00 UTC"  # 时区被转化为CST
  • as.POSIXct(x, tz = “”, …) ：以一个数值形式进行存储，精确到秒
    • 默认时区为当期的时区；中国为CST

tz = “” ；默认为当前的时区

  • as.POSIXlt() ：以列表的形式进行存储，精确到秒

as.POSIXct 与 as.POSIXlt 默认的时区为 CST

1
2
3
> > as.POSIXct("2017-04-21 00:09:21")
> [1] "2017-04-21 00:09:21 CST"
>
  • as.Date()：以数值形式存储，精确到天 【Basic函数】


  • parse_date_time(x, orders, tz = “UTC”, truncated = 0, quiet = FALSE, locale = Sys.getlocale(“LC_TIME”), select_formats = .select_formats, exact = FALSE)：将向量转换为POSIXct的日期时间格式

    parse_date_time 将格式各样的日期时间字符串转换为日期时间类型的数据，并通过orders指定显示的顺序

    • 与strftime的两点区别：
      1. 指定一个特殊的排列顺序，而无需使用 %
      2. 在处理复合的日期时间数据时，可同时指定多个排列顺序

x ：一个字符串 或数值 向量

order =c(“”): 指定的日期显示顺序 ； 若涉及到日期与时间，将时间的小写改为大写； eg ymd_HMS

tz =”UTC” ：世界标准市价

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
> x <- c("09-01-01", "09-01-02", "09-01-03")
> parse_date_time(x, "ymd")  # 标准时区UTC
[1] "2009-01-01 UTC" "2009-01-02 UTC" "2009-01-03 UTC"
## 复合时间 
# 处理复合的日期时间数据时，可同时指定多个排列顺序
x <- c("09-01-01", "090102", "09-01 03", "09-01-03 12:02")
parse_date_time(x, c("ymd", "ymd_HM"))
## 不同的排序规则 - 可以同时处理
> x <- c("2009-01-01", "02022010", "02-02-2010")
> parse_date_time(x, c("dmY", "ymd"))
[1] "2009-01-01 UTC" "2010-02-02 UTC" "2010-02-02 UTC"
## 季度与部分日期
> parse_date_time(c("2016.2", "2016-04"), orders = "Yq")  # q 代表季度;
[1] "2016-04-01 UTC" "2016-10-01 UTC" 
> parse_date_time(c("2016", "2016-04"), orders = c("Y", "Ym"))
[1] "2016-01-01 UTC" "2016-04-01 UTC"
# Y 与 y 的区别   # Y大写表示全称；y表示缩写；
> parse_date_time(c("16.2", "16-04"), orders = "yq")
[1] "2016-04-01 UTC" "2016-10-01 UTC"
> parse_date_time(c("16.2", "16-04"), orders = "Yq")
[1] NA NA


  • decimal_date(x)：将日期格式转化为小数格式；

x : a POSIXlt/ct or Date object

  • date_decimal(x) ：将小数转化为日期格式
1
2
3
4
5
6
date <- ymd("2009-02-10")
decimal_date(date)
[1] 2009.11
date_decimal(decimal_date(date))
[1] "2009-02-10 UTC"


  • unclass(x) ：
    • 可以将日期变成以天来计数 ；
    • 可以将时点类根据最基本的组成进行拆解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 x<-as.Date("1970-01-01") 
> unclass(x) 
[1] 0
> 
> unclass(as.Date("1970-02-01")) #19700201代表第31天
[1] 31
# --------对时点类时间进行拆解--------------------------------------
## POSIXct 格式；主要特点：以秒进行存储。
> unclass(now())  # 等价于 unclass(as.POSIXct(now()))
[1] 1501495056
attr(,"tzone")
[1] ""
## POSIXlt 格式；主要特点：以列表进行单独储存格式，可以作为时间筛选的一种
> unclass(as.POSIXlt(now()))
$sec
[1] 18.43142
$min
[1] 58
$hour
[1] 17
$mday
[1] 31
$mon
[1] 6
$year
[1] 117
$wday
[1] 1
$yday
[1] 211
$isdst
[1] 0
$zone
[1] "CST"
$gmtoff
[1] 28800
attr(,"tzone")
[1] ""    "CST" "CDT"

起始日期为1970-01-01


获取

  • today( [tz=””])：返回当前系统的日期，不含时间；时区默认为当前计算机的时区
  • now( [tz=””])：作为POSIXct对象返回当前系统的日期与时间 ；时区默认为当前计算机的时区
1
2
3
4
5
> today()
[1] "2017-07-31"
> now()
[1] "2017-07-31 15:43:46 CST"


舍入 - Rounding

  • round_date(x, unit = “second”) ：根据unit对x进行四舍五入；

unit =”” ：可选的单位

  • second(s) / mintue(s) / hour(s) / day(s)
  • week(s) / month(s) / quarter()
  • haflyear / year
  • floor_date(x, unit = “second”)：向下舍入；
    • 相当于取整；若unit=”hour” ，则舍去分钟的内容
  • ceiling_date(x, unit = “second”, change_on_boundary = NULL)：向上舍入；
    • 向上取整； 若后面一位小数大于0，即向前进一位

函数实际运行的三个步骤

  1. 转换为表示日期下限的时点：2000-01-01 –> 2000-01-01 00:00:00
  2. 向上舍入到下一个最接近的单位边界。 if the rounding unit is month then next boundary for 2000-01-01 will be 2000-02-01 00:00:00.
  3. 如果舍入的最小边界单位小于一天，则返回第二步的时点
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
## round_date--------------------------------------------------
x <- as.POSIXct("2009-08-03 12:01:59.23"); x
[1] "2009-08-03 12:01:59 CST"
round_date(x, "minute")  # 舍入到分钟
[1] "2009-08-03 12:02:00 CST"
> round_date(x, "5 minute")
[1] "2009-08-03 12:00:00 CST"
> round_date(x, "2 months")
[1] "2009-09-01 CST"
round_date(x, "quarter") == round_date(x, "3 months")
round_date(x, "halfyear")
round_date(x, "year")
## floor_date--------------------------------------------------
x <- as.POSIXct("2009-08-03 12:01:59.23")
> floor_date(x, "hour")
[1] "2009-08-03 12:00:00 CST"
## ceiling_date------------------------------------------------
x <- as.POSIXct("2009-08-03 12:01:59.23")
> ceiling_date(x, "second")
[1] "2009-08-03 12:02:00 CST"


设定时点

设定时点的两种方法：

  1. 通过解析函数设定
  2. 通过时段类函数设定
  • 通过解析函数设定
1
2
3
4
5
6
7
8
9
10
11
12
#解析日期
year(x)
#设定日期，通过赋值进行设定
year(x) <- value
> l <- today(); l
[1] "2017-07-31"
> day(l) <- 10; l
[1] "2017-07-10"
# 不可直接对today()进行赋值
day(today())<- 10  # 显示报错


  • 通过时段类函数直接设定
1
2
3
4
5
6
7
## 通过period来设定时间，一般为unit之后加s； 例如days / months
> today() + days(1)  
[1] "2017-08-01"
## 通过 duraction来设定时间，一般period之前加d；即对原始先加s，在加d； 例如 ddays / dyears
> today() + ddays(1)  
[1] "2017-08-01"


时段类


间隔 - Intervals

interval：最简单的时段对象，它由两个时点数据构成。

  • 间隔类型： is.intervals & as.intervals
  • interval(start, end, tzone = attr(start, “tzone”))：创建时间间隔
1
2
3
4
## 创建时间间隔
x <- ymd('2010-04-08')
interval(x,now())
[1] 2010-04-08 08:00:00 CST--2017-07-31 16:41:43 CST
  • int_length() ：间隔的长度，以秒来计算

  • int_start() / int_end() ：返回间隔的起始/结束日期时间

  • int_shift(int, by)：对间隔两端同时进行转换

by = duration( ): 一段持续时间或周期

1
2
3
4
5
6
7
## 转换
int <- interval(ymd("2001-01-01"), ymd("2002-01-01"))
int_shift(int, duration(days = 11))
[1] 2001-01-12 UTC--2002-01-12 UTC
int_shift(int, duration(hours = -1))
[1] 2000-12-31 23:00:00 UTC--2001-12-31 23:00:00 UTC


  • int_flip(int)：翻转；将interval的起始时间与结束时间对调
  • int_standardize()：标准化；确保间隔是正值，即结束时间大于开始时间；若非标准化，则自动调整
1
2
3
4
5
6
int <- interval(ymd("2001-01-01"), ymd("2002-01-01"))
int_flip(int)
[1] 2002-01-01 UTC--2001-01-01 UTC
int_standardize(int_flip(int))
[1] 2001-01-01 UTC--2002-01-01 UTC


  • int_diff(times)：时间间隔对象, 包含 n-1段的时间间隔

times为POSIXct, POSIXlt 或日期格式

1
2
3
4
5
6
> dates <- now() + days(1:4); dates
[1] "2017-08-01 17:00:07 CST" "2017-08-02 17:00:07 CST" "2017-08-03 17:00:07 CST" "2017-08-04 17:00:07 CST"
> int_diff(dates)
[1] 2017-08-01 17:00:07 CST--2017-08-02 17:00:07 CST 2017-08-02 17:00:07 CST--2017-08-03 17:00:07 CST
[3] 2017-08-03 17:00:07 CST--2017-08-04 17:00:07 CST


  • int_overlaps(int1, int2)：判断int1与int2之间是否有重叠的部分；并返回逻辑值 T/F

  • int_aligns(int1, int2)：判断int1与int2是否对齐，并返回逻辑值 T / F

aligns : 对齐

若int1与int2 有相同的起始时间或结束时间，则返回T； 否则返回FALSE

1
2
3
4
5
6
7
8
9
10
11
int1 <- interval(ymd("2001-01-01"), ymd("2002-01-01"))
int2 <- interval(ymd("2001-06-01"), ymd("2002-01-01"))
int3 <- interval(ymd("2003-01-01"), ymd("2004-01-01"))
int_aligns(int1, int2) # TRUE  ## 有相同的结束时间
int_aligns(int1, int3) # FALSE  
## 判断是否有重叠 
int_overlaps(int1, int2) # TRUE
int_overlaps(int1, int3) # FALSE


时间间隔

  • time_length(x, unit = “second”) ：计算两个时间之间的间隔 （自定义间隔单位）

x ：a duration, period, difftime or interval

unit = c(“second”, “minute”, “hour”,”day”, “week”,”month”, “year”))


  • difftime(endtime1, starttime2, tz,units=c(“”) ) ：计算两个时间之间的间隔 （自定义间隔单位）
    • time1 - time2 ； 该函数为Base函数

time1 ，常规的时间

units = c(“auto”, “secs”, “mins”, “hours”,”days”, “weeks”))


判断是否在时间段内

  • %within%： a %within% b
    • 若a等于b的一端，也返回TRUE

a : 可以是时点类，也可以是时段类

b：必须是时段类数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
arrive1<-"2011-08-10 13:50:00"
leave1<-"2011-08-10 14:00:09"
int1<-interval(arrive1,leave1)
# 时点类判断
> ymd_hms("2011-08-10 13:52:12") %within% int1
[1] TRUE
> ymd_hms("2011-08-10 13:50:00") %within% int1
[1] TRUE
# 时段类判断
arrive<-"2011-08-10 14:00:00"
leave<-"2011-08-10 14:00:05"
int<-interval(arrive,leave)
[1] 2011-08-10 14:00:00 UTC--2011-08-10 14:00:05 UTC
int1 %within% int
[1] FALSE
int %within% int1
[1] TRUE

报错：Argument 1 is not a recognized date-time；表明传入的第一个参数不是时点格式，需要进行转换


持续时间 - Durations

duration：去除了时间两端的信息，纯粹以秒为单位计算时段的长度，不考虑闰年和闰秒，它同时也兼容基本包中的difftime类型对象。

  • 期间类型 ： is.duration(x) & as.duration
  • duration(num = NULL, units = “seconds”, …)：创建持续时间
1
2
3
4
5
6
7
8
duration(90, "seconds")
duration(1.5, "minutes")
## 比较判断
duration("day 2 sec") > "day 1sec"
is.duration(as.Date("2009-08-03")) # FALSE
is.duration(duration(days = 12.4)) # TRUE


  • dyears(x) / dweeks(x) / ddays(x) /dhours(x) / dminutes(x) / dseconds(x) ：快速创建持续时间的对象以便于进行日期时间操作
    • 没有dmonths()，因为其以秒为单位来创建，而月度常在30天/31天之间变化；而年度的话此时默认为365天；

Durations的函数，以 [秒] 为单位进行创建

  • minutes(2)函数表示的2个整分钟的概念，而dminutes(2)则是具体120秒
  • years(1)则是一个整年的概念而dyears(1)表示的365天**而
1
2
3
4
5
6
7
8
9
10
11
12
## 规则说明：以 [秒] 为单位进行创建
> dyears(1)
[1] "31536000s (~52.14 weeks)"
> years(1)
[1] "1y 0m 0d 0H 0M 0S"
## 具体区别
> ymd('20160228')+dyears(1)  # 以秒为单位进行扩展
[1] "2017-02-27"
> ymd('20160228')+years(1)  # 以年为单位进行扩展
[1] "2017-02-28"


周期 - Periods

period：以较长的时钟周期来计算时段长度，它考虑了闰年和闰秒，适用于长期的时间计算。

  • 周期类型： is.period & as.period
  • period(num = NULL, units = “second”, …)：创建周期
1
2
3
4
5
> period(-1, "days")
[1] "-1d 0H 0M 0S"
> period(c(3, 1, 2, 13, 1), c("second", "minute", "hour", "day", "week"))
[1] "20d 2H 1M 3S"


  • years(x) / months(x) / weeks(x) / days(x) / hours(x) / minutes() / seconds(x)：快速创建阶段对象以便于进行日期时间操作

Durations的函数，以 [创建的函数单位] 为单位进行创建

  • minutes(2)函数表示的2个整分钟的概念，而dminutes(2)则是具体120秒
  • years(1)则是一个整年的概念而dyears(1)表示的365天而
1
2
3
4
5
6
7
8
9
10
11
# 规则说明：以[创建的函数单位]为单位进行创建
> dyears(1)
[1] "31536000s (~52.14 weeks)"
> years(1)
[1] "1y 0m 0d 0H 0M 0S"
# 具体应用
> x <- as.POSIXct("2009-08-03");x
[1] "2009-08-03 CST"
> x + days(1) + hours(6) + minutes(30)
[1] "2009-08-04 06:30:00 CST"


时区 - Time Zones

时区索引

  • tz(x)：提取时间数据的时区
  • with_tz(time, tz=””)：将时间数据[显示] 为另一个时区的同一时间
  • force_tz(timez, tz=””)：将时间数据的时区[强制转换] 为另一个时区
1
2
3
4
5
6
7
8
9
10
11
12
13
14
tz(x) <- value  # 设置时区
> meeting <- ymd_hms("2011-07-01 09:00:00", tz = "Pacific/Auckland");meeting
[1] "2011-07-01 09:00:00 NZST"
> with_tz(meeting, "America/Chicago")    #显示不同的时区相同的时刻
[1] "2011-06-30 16:00:00 CDT"
> mistake <- force_tz(meeting, "America/Chicago");mistake  # 强制转化为另一个时区
[1] "2011-07-01 09:00:00 CDT"
> with_tz(mistake, "Pacific/Auckland")  # 显示转化之后的另一个时间的同一时间，判断是否转换成功
[1] "2011-07-02 02:00:00 NZST"



混杂的 - Miscellaneous

  • leap_years(x) : 判断是否为闰年
  • pretty_dates() : provides a method of making pretty breaks for date-times


时间单位转换

  • make_difftime(num = NULL, units = “auto”) :
1
2
3
4
5
make_difftime(3600, units = "minute")
# Time difference of 60 mins
make_difftime(second = 3, minute = 1.5, hour = 2, day = 6, week = 1)
# Time difference of 13.08441 days
  • %m+% ：由于每个月的最后天数不一样，如果直接在某个月份的最后一天加上指定的月数就会出现错误，这时就得考虑使用%m+%函数了。
1
2
3
4
5
6
7
8
x <- as.Date('2015-01-31')
y <- x + months(0:11); y
 [1] "2015-01-31" NA           "2015-03-31" NA           "2015-05-31" NA           "2015-07-31" "2015-08-31"
 [9] NA           "2015-10-31" NA           "2015-12-31"
> x %m+% months(0:11)
 [1] "2015-01-31" "2015-02-28" "2015-03-31" "2015-04-30" "2015-05-31" "2015-06-30" "2015-07-31" "2015-08-31"
 [9] "2015-09-30" "2015-10-31" "2015-11-30" "2015-12-31"



应用

选择某个时间/时间段的数据

  • 转为日期格式： as_data() 或 ymd()
1
2
3
4
5
6
7
> head(date$建仓日期,1)
[1] "2017-08-14 10:01:00 CST"
filter(date, as_date(建仓时间)==as_date('2017-08-16')) 
# ----某个时间段
filter(data, as_date(建仓时间) >= as_date('2017-08-11') & as_date(建仓时间) <= as_date('2017-08-16'))
  • 转为字符串格式

可以直接用字符串函数进行操作，而无需先转换格式

1
2
3
4
filter(data, str_sub(as.character(建仓时间),1,10) == '2017-08-16')
# 等价于如上
filter(data, str_sub(建仓时间,1,10) == '2017-08-16')


增减日期

  • 通过持续时间来增减日期
    • duration：去除了时间两端的信息，纯粹以秒为单位计算时段的长度，不考虑闰年和闰秒，它同时也兼容基本包中的difftime类型对象。
  • 通过周期来增减日期
    • period：以较长的时钟周期来计算时段长度，它考虑了闰年和闰秒，适用于长期的时间计算。
1
2
3
4
5
6
7
# 持续时间 --以秒为单位进行扩展
> ymd('20160228')+dyears(1)  
[1] "2017-02-27"
# 周期 --以年为单位进行扩展
> ymd('20160228')+years(1) 
[1] "2017-02-28"


新增列，并转化格式

1
2
data_source1 <- mutate(data_source, 结算日期 = ifelse(str_sub(建仓时间,12,19) > '15:00:00',as_date(建仓时间) + days(1, as_date(建仓时间))
data_source1$结算日期 <- as_date(data_source1$结算日期)


输出格式 - 提取部分值 - format

连续

1
2
3
as_date("2017-08-30") %>% format(., format="%y%m%d")  # format= "%m/%d"
labels=format(as_date(""),format="")