R入門
日付と時刻
最終更新：
r-intro
目次
- 目次
- 日付型ベクトルの宣言と初期化
- 現在の日時を取得する
- 年月日（数値型）から日付型ベクトルを作成する
- 文字列から日付を作成する
- 書式を指定して文字列型ベクトルを日付型ベクトルに変換する
- 日付型ベクトルから年、月、日を取り出す
- 日付型ベクトルから年、月、日を抜き出す
- 日時の計算を行う
- 日付からその日の曜日を得る。
- 同じ値を繰り返してかつ連続したベクトルを作る
- 日付を文字列に変換する
- 月の日数を得る
- 日付型ベクトルから年、月、日を数値型ベクトルで取り出す
- 文字列から時刻を作成する
- 文字列から日付時刻を作成する
- nか月後の日付を得る
- n日後の日付を得る
- n年後の日付を得る
- スクリプト内で処理時間を計算して表示する
- 日や時間などをしてして日付時刻型ベクトルを作成する
- 日付時刻型ベクトルの特定の要素（年、月、日、時、分、秒）だけを修正する
- 2つの日付から年の差を得る
- 現在の環境のタイムゾーンを得る
- タイムゾーンIDを一覧形式で得る
- 日付時刻型ベクトルを作成する
- 日付時刻型ベクトルを作成する
- 区切り文字に．（ドット）を使った日付文字列を日付に変換する
- 何か月後か調べる
- ymd_hms関数で作成される日付時刻型ベクトルのタイムゾーンについて
- 日付時刻型ベクトルの日付時刻を指定のタイムゾーンの日付時刻に変更する
- 日付時刻型ベクトルのタイムゾーンを変更する
- 日付のタイムゾーンを得る
日付型ベクトルの宣言と初期化
日付を扱うための変数（ベクトル）を使うには、その日付を格納する領域を用意して、それに名前を付ける必要がある。これを宣言という。
日付型変数（ベクトル）はas.Date関数に書式に従った文字列リテラルを与えることで宣言することができる。ベクトルの長さを得るにはlength関数を使う。
> dt <- as.Date(c("2001-01-01", "2001-01-03"))
> print(dt)
[1] "2001-01-01" "2001-01-03"
> length(dt)
[1] 2現在の日時を取得する
日付だけであればSys.Date関数を、日時を得る場合はSys.time関数を使う。
Sys.Date関数の戻り値は日付型で、Sys.time関数の戻り値はPOSIXct型である。
年月日（数値型）から日付型ベクトルを作成する
ISOdate関数を使う。戻り値はPOSIXct。タイムゾーンを指定しないとGMTになってしまうことに注意。タイムゾーンの情報が不要であれば、戻り値をas.Date関数に通すと通常の日付型になる。
> ISOdate(2000, 1, 24)
[1] "2000-01-24 12:00:00 GMT"
> ISOdate(2000, 1, 24, tz = "Japan")
[1] "2000-01-24 12:00:00 JST"
> class((ISOdate(2000, 1, 24)))
[1] "POSIXct" "POSIXt"
> as.Date((ISOdate(2000, 1, 24)))
[1] "2000-01-24"文字列から日付を作成する
as.Date関数もしくはstrptime関数を使う。as.Dateは一部の書式にしか対応しておらず、as.Date関数で対応していない書式の場合は、strptime関数を使う。
> s1 <- c("1991/02/03", "1991/2/3")
> s2 <- c("1991-02-03", "1991-2-3")
> s3 <- c("91/2/3")
> as.Date(c(s1, s2, s3))
[1] "1991-02-03" "1991-02-03" NA NA "0091-02-03"
> strptime(s2, "%Y-%m-%d")
[1] "1991-02-03 JST" "1991-02-03 JST"
> strptime(s3, "%y/%m/%d")
[1] "1991-02-03 JST"%Yなどの書式文字列については、strptimeのヘルプを参照のこと。
> ?strptime書式を指定して文字列型ベクトルを日付型ベクトルに変換する
strptime関数を使う。戻り値はPOSIXlt型（時刻とタイムゾーンを持つ日付型で、実態は秒単位の整数型）。
> s <- c("2001-02-03", "2002-04-05")
> strptime(s, "%Y-%m-%d")
[1] "2001-02-03 JST" "2002-04-05 JST"
> s <- c("2001/02/03", "2002/04/05")
> strptime(s, "%Y/%m/%d")
[1] "2001-02-03 JST" "2002-04-05 JST"
> dt <- strptime(s, "%Y/%m/%d")
> class(dt)
[1] "POSIXlt" "POSIXt"POSIXlt型のため、時刻も扱える（タイムゾーンも）。
> s <- c("2001-02-03T12:24:56", "2002-04-05T01:02:03")
> strptime(s, "%Y-%m-%dT%H:%M:%S")
[1] "2001-02-03 12:24:56 JST" "2002-04-05 01:02:03 JST"POSIXlt型の実態は秒単位の整数型のため、整数で演算をすると、以下のような結果になる。
> dt <- strptime(s, "%Y-%m-%dT%H:%M:%S")
> dt
[1] "2001-02-03 12:34:56 JST" "2002-04-05 01:02:03 JST"
> dt + 3
[1] "2001-02-03 12:34:59 JST" "2002-04-05 01:02:06 JST"書式はstrptimeに書かれている。
> ?strptime日付型ベクトルから年、月、日を取り出す
POSIXlt型ベクトルかformat関数を使う。POSIXlt型ベクトルは、日付の構成要素（年、月、日など）を簡単に取り出せる。年はyear、月はmon、日はmday。ただしyearは1900からの通算数、monは0からの通算数であることに注意。format関数は日付型ベクトルを文字型ベクトルに変換する関数だが、得られた文字列を数値型ベクトルに変換すればよい。
> today <- as.Date("2020-07-23")
> as.POSIXlt(today)$year + 1900
[1] 2020
> as.integer(format(today, "%Y"))
[1] 2020
> as.POSIXlt(today)$mon + 1
[1] 7
> as.integer(format(today, "%m"))
[1] 7
> as.POSIXlt(today)$mday
[1] 23
> as.integer(format(today, "%d"))
[1] 23①POSIXlt型ベクトルを使う、②format関数とas.integer関数を組み合わせて使う、どちらの処理が早いかsystem.time関数で計測してみる。
> date1 <- as.Date("1000-01-01")
> date2 <- as.Date("3000-12-31")
> dateall <- seq(date1, date2, by = "day")
> length(dateall)
[1] 730850
> system.time(as.POSIXlt(dateall)$mon + 1)
ユーザ システム 経過
0.53 0.00 0.53
> system.time(as.integer(format(dateall, "%m")))
ユーザ システム 経過
1.99 0.02 2.00POSIXlt型ベクトルを使う①の処理が圧倒的に早いため、①の手順で行ったほうがよい。
日付型ベクトルから年、月、日を抜き出す
format関数を使う。format関数は抜き出した結果を文字型ベクトルで返すため、用途に応じてas.XXX関数を使って変換する。以下は、それぞれ年、月、日を抜き出した例。最後は抜き出した日を整数に変換している。
> dt <- c(as.Date("2000-01-03"), as.Date("2000-02-01"))
> dt
[1] "2000-01-03" "2000-02-01"
> format(dt, "%Y")
[1] "2000" "2000"
> format(dt, "%m")
[1] "01" "02"
> format(dt, "%d")
[1] "03" "01"
> as.integer(format(dt, "%m"))
[1] 1 2日時の計算を行う
difftime関数を使う。引数に、比較をする日、基準とする日の順に日付オブジェクトを与える。unitsオプションにいろいろ与えることで、返却値の単位を指定することができる。
> dt1 <- as.Date("2002-01-02")
> dt2 <- as.Date("2002-01-05")
> difftime(dt2, dt1)
Time difference of 3 days
> difftime(dt2, dt1, units = "hours")
Time difference of 72 hours
> difftime(dt2, dt1, units = "days")
Time difference of 3 days
> difftime(dt2, dt1, units = "hours")
Time difference of 72 hours返却値の値は計算に使用することができる。
> n <- difftime(dt2, dt1, units = "hours")
> print(n / 8)
Time difference of 9 hours日付からその日の曜日を得る。
weekdays関数を使う。以下は2021年の4月1～3日の曜日を得る例。
> d <- seq(as.Date("2021-04-01"), length = 3, by = "1 day")
> d
[1] "2021-04-01" "2021-04-02" "2021-04-03"
> weekdays(d)
[1] "木曜日" "金曜日" "土曜日"特定の1日であれば、以下のようにする。西暦1年1月1日の曜日は月曜日であることがわかる。
> weekdays(as.Date("0001-01-01"))
[1] "月曜日"同じ値を繰り返してかつ連続したベクトルを作る
同じ値が連続したベクトルを作るにはrep関数を使うが、
> rep(1, 3)
[1] 1 1 1同じ値が繰り返してかつ連続したベクトルを作るには（たとえば1,1,1,2,2,2,3,3,3,…）、rep関数にeachオプションを付けて使う。
> rep(1:3, 3)
[1] 1 2 3 1 2 3 1 2 3
> rep(1:3, 1, each = 3)
[1] 1 1 1 2 2 2 3 3 3日付型も使える。
> dt1 <- as.Date("2022-01-01")
> dt2 <- as.Date("2022-01-03")
> rep(seq(dt1, dt2, by = "day"), 3)
[1] "2022-01-01" "2022-01-02" "2022-01-03"
[4] "2022-01-01" "2022-01-02" "2022-01-03"
[7] "2022-01-01" "2022-01-02" "2022-01-03"
> rep(seq(dt1, dt2, by = "day"), 1, each = 3)
[1] "2022-01-01" "2022-01-01" "2022-01-01"
[4] "2022-01-02" "2022-01-02" "2022-01-02"
[7] "2022-01-03" "2022-01-03" "2022-01-03"日付を文字列に変換する
format関数を使う。format関数はベクトルを扱える。文字列に変換する書式はformatオプションを使うことができる。
> da <- as.Date(c("2014-12-01", "2014-12-31"))
> format(da)
[1] "2014-12-01" "2014-12-31"
> mode(format(da))
[1] "character"
> class(format(da))
[1] "character"
> format(da, format = "%Y/%m/%d")
[1] "2014/12/01" "2014/12/31"月の日数を得る
lubridateパッケージのdays_in_month関数を使う。例えば、2000年2月の日数（この年は閏年のため29）、2022年8月の日数（31）を求める。
> library(lubridate)
> dt <- as.Date(c("2000-02-01", "2022-08-01"))
> days_in_month(dt)
Feb Aug
29 31
> typeof(days_in_month(dt))
[1] "integer"HmiscパッケージのmonthDays関数も使える。
> library(Hmisc)
> dt <- as.Date(c("2000-02-01", "2022-08-01"))
> monthDays(dt)
[1] 29 31
> typeof(monthDays(dt))
[1] "integer"日付型ベクトルから年、月、日を数値型ベクトルで取り出す
lubridateパッケージのyear,month,day関数を使う。
> library(lubridate)
> dt <- seq(as.Date("2022-11-02"), as.Date("2023-02-02"), by = "month")
> print(dt)
[1] "2022-11-02" "2022-12-02" "2023-01-02" "2023-02-02"
> print(year(dt))
[1] 2022 2022 2023 2023
> print(month(dt))
[1] 11 12 1 2
> print(day(dt))
[1] 2 2 2 2同様に時分秒を取り出すためのhour,minute,second関数もあるが、日付型ベクトル（as.Date）の場合は0が戻る。
> print(hour(dt))
[1] 0 0 0 0
> print(minute(dt))
[1] 0 0 0 0
> print(second(dt))
[1] 0 0 0 0文字列から時刻を作成する
strptime関数を使う。Rには時刻型というベクトル（変数）はなく、日付とワンセットであるため、時刻だけを扱おうとすると、自動的にその日の日付として処理されてしまうことに注意。
> Sys.time()
[1] "2023-06-27 23:37:26 JST"
> strptime(c("12", "34"), "%S")
[1] "2023-06-27 00:00:12 JST" "2023-06-27 00:00:34 JST"
> strptime(c("12:34", "34:56"), "%M:%S")
[1] "2023-06-27 00:12:34 JST" "2023-06-27 00:34:56 JST"
> strptime(c("12:34:56", "22:34:56"), "%H:%M:%S")
[1] "2023-06-27 12:34:56 JST" "2023-06-27 22:34:56 JST"文字列から日付時刻を作成する
strptime関数を使う。
> strptime(c("2001/02/03 12:34:56", "2012/03/04 01:02:03"), "%Y/%m/%d %H:%M:%S")
[1] "2001-02-03 12:34:56 JST" "2012-03-04 01:02:03 JST"日付時刻の書式を指定する書式文字列については、strptime関数のヘルプに詳しい。
> ?strptimenか月後の日付を得る
lubridateパッケージのmonths関数を使う。引数には加算（減算）したい月数を整数で指定する。引数に「1」を指定すれば翌月、「-1」を指定すれば前月の日付を返す。
ymdはlubridateパッケージに含まれる、文字列から日付を得る関数。months関数の引数にベクトルを指定すれば、ベクトル単位で計算を行う。
> library(lubridate)
> da <- ymd("2000-12-23", "2123-04-05")
> print(da)
[1] "2000-12-23" "2123-04-05"
> da <- da + months(1)
> print(da)
[1] "2001-01-23" "2123-05-05"
> da <- da + months(-2)
> print(da)
[1] "2000-11-23" "2123-03-05"
> da <- da + months(12)
> print(da)
[1] "2001-11-23" "2124-03-05"
> ymd("2000-12-23") + months(2:3)
[1] "2001-02-23" "2001-03-23"
> ymd("2000-12-23", "2010-12-23") + months(2:3)
[1] "2001-02-23" "2011-03-23"n日後の日付を得る
lubridateパッケージのdays関数を使う。引数には加算（減算）したい日数を整数で指定する。引数に「1」を指定すれば翌日、「-1」を指定すれば前日の日付を返す。
ymdはlubridateパッケージに含まれる、文字列から日付を得る関数。days関数の引数にベクトルを指定すれば、ベクトル単位で計算を行う。
> library(lubridate)
> da <- ymd("2000-12-23", "2123-04-05")
> print(da)
[1] "2000-12-23" "2123-04-05"
> da <- da + days(2)
> print(da)
[1] "2000-12-25" "2123-04-07"
> da <- da + days(-5)
> print(da)
[1] "2000-12-20" "2123-04-02"
> da <- da + days(365)
> print(da)
[1] "2001-12-20" "2124-04-01"
> ymd("2000-12-23") + days(2:3)
[1] "2000-12-25" "2000-12-26"
> ymd("2000-12-23", "2010-12-23") + days(2:3)
[1] "2000-12-25" "2010-12-26"n年後の日付を得る
lubridateパッケージのyears関数を使う。引数には加算（減算）したい月数を整数で指定する。引数に「1」を指定すれば翌年、「-1」を指定すれば前年の日付を返す。
ymdはlubridateパッケージに含まれる、文字列から日付を得る関数。years関数の引数にベクトルを指定すれば、ベクトル単位で計算を行う。
> library(lubridate)
> da <- ymd("2000-12-23", "2123-04-05")
> da <- da + years(1)
> print(da)
[1] "2001-12-23" "2124-04-05"
> da <- da + years(-2)
> print(da)
[1] "1999-12-23" "2122-04-05"
> ymd("2000-12-23") + years(2:3)
[1] "2002-12-23" "2003-12-23"
> ymd("2000-12-23", "2010-12-23") + years(2:3)
[1] "2002-12-23" "2013-12-23"スクリプト内で処理時間を計算して表示する
開始時と終了時にそれぞれSys.time関数で現在の日時を取得し、最後にdifftime関数でその差を計算して表示すればよい。以下をスクリプトファイルdifftime.Rに保存をして、実行してみる。途中にSys.sleep関数を使用して意図的に3秒間処理を止めている。
dtibegin <- Sys.time()
Sys.sleep(3)
dtiend <- Sys.time()
d <- difftime(dtiend, dtibegin, units = "secs")
cat(sprintf("処理時間: %.2f秒\n", d))実行結果
> source("difftime.R")
処理時間: 3.07秒日や時間などをしてして日付時刻型ベクトルを作成する
lubridateパッケージのymd_hms関数を使う。年、月、日、時、分、秒をすべて指定する必要がある。tzオプションにタイムゾーンの情報も適切に指定する必要がある。指定しないとUTCの日付時刻を作成する。
> library(lubridate)
> dttm <- ymd_hms("2012-12-31")
警告メッセージ:
All formats failed to parse. No formats found.
> dttm <- ymd_hms("2012-12-31 12:34:56")
> print(dttm)
[1] "2012-12-31 12:34:56 UTC"
> dttm <- ymd_hms("2012-12-31 12:34:56", "2034-01-02 23:45:12")
> print(dttm)
[1] "2012-12-31 12:34:56 UTC" "2034-01-02 23:45:12 UTC"
> dttm <- ymd_hms("2012-12-31 12:34:56", "2034-01-02 23:45:12", tz = "Japan")
> print(dttm)
[1] "2012-12-31 12:34:56 JST" "2034-01-02 23:45:12 JST"
> dttm <- ymd_hms("2012-12-31 12:34:56", "2034-01-02 23:45", tz = "Japan")
警告メッセージ:
1 failed to parse.
> typeof(dttm)
[1] "double"
> class(dttm)
[1] "POSIXct" "POSIXt"
> mode(dttm)
[1] "numeric"日付時刻型ベクトルの特定の要素（年、月、日、時、分、秒）だけを修正する
lubridateパッケージのupdate関数を使う。
> library(lubridate)
> dttm <- ymd_hms("2012-12-31 12:34:56", "2034-01-02 23:45:12", tz = "Japan")
> print(dttm)
[1] "2012-12-31 12:34:56 JST" "2034-01-02 23:45:12 JST"
> update(dttm, month = 3)
[1] "2012-03-31 12:34:56 JST" "2034-03-02 23:45:12 JST"
> update(dttm, hour = 7)
[1] "2012-12-31 07:34:56 JST" "2034-01-02 07:45:12 JST"2つの日付から年の差を得る
簡単に求めるには、以下のようにseq関数とlength関数を組み合わせればよい。差が1年未満であれば0、1年～2年未満であれば1、…が得られる。
> length(seq(as.Date("2020-02-15"), as.Date("2020-02-15"), by = "year")) - 1
[1] 0
> length(seq(as.Date("2020-02-15"), as.Date("2020-02-16"), by = "year")) - 1
[1] 0
> length(seq(as.Date("2020-02-15"), as.Date("2021-02-14"), by = "year")) - 1
[1] 0
> length(seq(as.Date("2020-02-15"), as.Date("2021-02-15"), by = "year")) - 1
[1] 1
> length(seq(as.Date("2020-02-15"), as.Date("2021-02-16"), by = "year")) - 1
[1] 1
> length(seq(as.Date("2020-02-15"), as.Date("2031-02-14"), by = "year")) - 1
[1] 10
> length(seq(as.Date("2020-02-15"), as.Date("2031-02-15"), by = "year")) - 1
[1] 11
> length(seq(as.Date("2020-02-15"), as.Date("2031-02-16"), by = "year")) - 1
[1] 11現在の環境のタイムゾーンを得る
Sys.timezone関数を使う。以下は、Windowsの日本語版バージョン4.3.1で実行した例。
> Sys.timezone()
[1] "Asia/Tokyo"タイムゾーンIDを一覧形式で得る
その環境下に搭載されているタイムゾーンを識別するID（タイムゾーンID）を一覧形式で得るには、OlsonNames関数を使う。
> OlsonNames()
[1] "Africa/Abidjan" "Africa/Accra"
[3] "Africa/Addis_Ababa" "Africa/Algiers"
[5] "Africa/Asmara" "Africa/Asmera"
（以下、表示省略）
> grep("Tokyo", OlsonNames())
[1] 322
> grep("Tokyo", OlsonNames(), value = TRUE)
[1] "Asia/Tokyo"日付時刻型ベクトルを作成する
as.POSIXct関数を使うと、文字列から簡単に日付時刻型ベクトルを作ることができる。format関数を使うと、第1引数に与えた日付時刻型ベクトルから文字列型ベクトルを作ることができる。その際の出力は、加工することができる。
> as.POSIXct("2001-12-23 12:34:56")
[1] "2001-12-23 12:34:56 JST"
> dtm <- as.POSIXct("2001-12-23 12:34:56")
> mode(dtm)
[1] "numeric"
> class(dtm)
[1] "POSIXct" "POSIXt"
> format(dtm, "%Y/%m/%d %H時%M分%S秒 %Z")
[1] "2001/12/23 12時34分56秒 JST"
> dtm <- as.POSIXct(c("2001-12-23 12:34:56", "2002-02-23 23:45:12"))
> dtm
[1] "2001-12-23 12:34:56 JST" "2002-02-23 23:45:12 JST"
> format(dtm, "%Y/%m/%d %H時%M分%S秒")
[1] "2001/12/23 12時34分56秒" "2002/02/23 23時45分12秒"日付時刻型ベクトルを作成する
readrパッケージのparse_datetime関数を使うと、文字列から簡単に日付時刻型ベクトルを作ることができる。ただし、その際はタイムゾーンを指定する必要がある。。format関数を使うと、第1引数に与えた日付時刻型ベクトルから文字列型ベクトルを作ることができる。その際の出力は、加工することができる。
> library(readr)
> parse_datetime("2001-12-23 12:34:56")
[1] "2001-12-23 12:34:56 UTC"
> Sys.timezone()
[1] "Asia/Tokyo"
> parse_datetime("2001-12-23 12:34:56", locale = locale(tz = "Asia/Tokyo"))
[1] "2001-12-23 12:34:56 JST"
> dtm <- parse_datetime("2001-12-23 12:34:56", locale = locale(tz = "Asia/Tokyo"))
> mode(dtm)
[1] "numeric"
> class(dtm)
[1] "POSIXct" "POSIXt"
> format(dtm, "%Y/%m/%d %H時%M分%S秒 %Z")
[1] "2001/12/23 12時34分56秒 JST"
> dtm <- parse_datetime(c("2001-12-23 12:34:56", "2002-02-23 23:45:12"), locale = locale(tz = "Asia/Tokyo"))
> dtm
[1] "2001-12-23 12:34:56 JST" "2002-02-23 23:45:12 JST"
> format(dtm, "%Y/%m/%d %H時%M分%S秒 %Z")
[1] "2001/12/23 12時34分56秒 JST" "2002/02/23 23時45分12秒 JST"区切り文字に．（ドット）を使った日付文字列を日付に変換する
as.Date関数もstrptime関数もデフォルトでは区切り文字に．（ドット）を使うことはできない。formatオプションに書式を指定すればよい。lubridateパッケージのymd関数はデフォルトの状態で変換することができる。
> s <- c("2001.2.3", "2012.3.4", "2123.4.5")
> as.Date(s)
charToDate(x) でエラー:
文字列は標準的な曖昧さのない書式にはなっていません
> as.Date(s, format = "%Y.%m.%d")
[1] "2001-02-03" "2012-03-04" "2123-04-05"
> strptime(s)
strptime(s) でエラー:
引数 "format" がありませんし、省略時既定値もありません
> strptime(s, format = "%Y.%m.%d")
[1] "2001-02-03 JST" "2012-03-04 JST" "2123-04-05 JST"
> lubridate::ymd(s)
[1] "2001-02-03" "2012-03-04" "2123-04-05"何か月後か調べる
seq関数とlength関数を組み合わせれば計算できる。以下の例では2024年1月16日を基準にして何か月後か調べた例。
> da <- as.Date("2024-01-16")
> length(seq(da, as.Date("2024-01-25"), by = "month")) - 1
[1] 0
> length(seq(da, as.Date("2024-02-25"), by = "month")) - 1
[1] 1
> length(seq(da, as.Date("2024-03-25"), by = "month")) - 1
[1] 2
> length(seq(da, as.Date("2025-03-25"), by = "month")) - 1
[1] 14ymd_hms関数で作成される日付時刻型ベクトルのタイムゾーンについて
実行環境如何に関わらず作成時にタイムゾーン（等時帯）を明示的に指定をしなければ、UTC（協定世界時）の日付時刻が作成されるので注意。この場合、文字列で指定した時刻がUTCに変換されるわけではなく、指定した文字列のUTCが作成されてしまう。JST（日本標準時）で作成したければ、タイムゾーンを適切に指定すること。
> Sys.timezone()
[1] "Asia/Tokyo"
> dttm <- ymd_hms(c("2001-02-03T04:05:06", "2010-11-12T13:14:15"))
> print(dttm)
[1] "2001-02-03 04:05:06 UTC" "2010-11-12 13:14:15 UTC"
> dttm <- ymd_hms("2001-02-03T04:05:06", tz = Sys.timezone())
> print(dttm)
[1] "2001-02-03 04:05:06 JST"日付時刻型ベクトルの日付時刻を指定のタイムゾーンの日付時刻に変更する
with_tz関数を使う。指定の日付時刻を指定のタイムゾーンに応じて時刻を変換する。
以下の例では、タイムゾーンが日本標準時（JST）の日付時刻を太平洋標準時（PST）に変換した例。JSTとPSTの時差は17時間（PST+17=JST）のため、PSTに変換した日付時刻が17時間戻っていることが分かる。
例えば、読み込むときに日付はそのままに誤ってUTCとして読み込んでしまった場合などにJSTであると強制的に書き換える場合などに使える。
> library(lubridate)
> dttm1 <- ymd_hms("2001-02-03 04:05:06", tz = "Asia/Tokyo")
> print(dttm1)
[1] "2001-02-03 04:05:06 JST"
> dttm2 <- with_tz(dttm1, tz = "America/Los_Angeles")
> print(dttm2)
[1] "2001-02-02 11:05:06 PST"日付時刻を変換するのではなくタイムゾーンの情報を変更する場合は、force_tz関数を使う。
日付時刻型ベクトルのタイムゾーンを変更する
force_tz関数を使う。指定のタイムゾーンに応じて時刻を変換するのではなく、ベクトルに保存されているタイムゾーンの情報だけを強制的に書き換えることに注意。
例えば、読み込むときに日付はそのままに誤ってUTCとして読み込んでしまった場合などにJSTであると強制的に書き換える場合などに使える。
> library(lubridate)
> Sys.timezone()
[1] "Asia/Tokyo"
> dttm <- ymd_hms("2001-02-03 04:05:06")
> print(dttm)
[1] "2001-02-03 04:05:06 UTC"
> dttm <- force_tz(dttm, tzone = Sys.timezone())
> print(dttm)
[1] "2001-02-03 04:05:06 JST"タイムゾーンの情報を変えるのではなく日付時刻を指定のタイムゾーンに変換する場合は、with_tz関数を使う。
日付のタイムゾーンを得る
lubridateパッケージのtz関数を使う。
> library(lubridate)
> da <- ymd("2012-03-04", tz = "Asia/Tokyo")
> print(da)
[1] "2012-03-04 JST"
> tz(da)
[1] "Asia/Tokyo"
> da <- ymd("2012-03-04", tz = "US/Pacific")
> print(da)
[1] "2012-03-04 PST"
> tz(da)
[1] "US/Pacific"以下の例のとおり、Rの動作環境から得られる日付時刻はタイムゾーンの情報を持たないことに注意。持たないイコールUTCになる。
