関数リファレンス

Logical

! 次の条件の意味を反転します。これは論理否定であり、「Not」と同様の意味を持ちます。
all 行またはグループ内の行ですべての行が指定した条件を満たす場合、TRUEを返します。
any 行またはグループ内の行で指定した条件を満たすものが一つでもある場合、TRUEを返します。
duplicated 重複した値または行であるかどうかを（TRUE、FALSE）で返します論理値。
ifelse 条件の結果に基づいて、異なる値を返します。
is.character 指定されたオブジェクトがCharacter（文字列）型の場合はTRUEを返します。
is.double 指定されたオブジェクトがDouble（不動小数点）型の場合はTRUEを返します。
is.factor 指定されたオブジェクトがFactor（順序付きカテゴリー型）の場合はTRUEを返します。
is.list 指定されたオブジェクトがList型の場合はTRUEを返します。
is.logical 指定されたオブジェクトがLotical（論理値）型の場合はTRUEを返します。
is.matrix 指定されたオブジェクトがMatrix型の場合はTRUEを返します。
is.na 欠損値の場合にTRUEを返します。
is.null nullの場合にTRUEを返します。
is.numeric 指定されたオブジェクトがNumeric（数値）型の場合はTRUEを返します。
isTRUE 指定された値がTRUEである場合にのみTRUEを返します。
which 論理ベクトル内の値の位置を返します。
xor 2つの値の排他的論理和のチェックを実行し、2つの値のうち1つだけがTRUEの場合のみTRUEを返します。
is.Date 指定したオブジェクトが日付型の場合はTRUEを返します。
is.difftime 指定したオブジェクトがdifftime型の場合はTRUEを返します。
is.duration 指定したオブジェクトがduration型の場合はTRUEを返します。
is.POSIXct 指定したオブジェクトがPOSIXct型の場合はTRUEを返します。
str_detect 特定の文字列が含まれているかどうかに基づいて、TRUEまたはFALSEを返します。
if_else 指定した条件を満たすかどうかに応じて、値を返します。
case_when 複数の条件にもとづいて値を返します。これはSQLのCASE WHENに似ています。条件とそれに対応する値を指定するために両辺の式を使い、ELSE条件としてTRUEを使用することができます。詳しくは以下の例を参照してください。
coalesce 欠損値を特定の値または他の列の同じ位置にある値に置き換えます。
na_if 一致する値をNAに置き換えます。
near 2つの数値ベクトルを比較します。浮動小数点数の2つのベクトルが（対で）等しいかどうかを比較する安全な方法です。許容誤差が組み込まれている点におい、== を使うよりも安全です。
recode_factor 元の値を指定された値で置換し、順序付きカテゴリの列を作成します。数値の場合、値にバックティックを付けるか、その位置にもとづいて置き換えることができ、文字列は、その名称をもとに置き換えることができます。
parse_logical データをLogical（論理値）型に変換します。
is.hms 指定したオブジェクトがhms型の場合はTRUEを返します。
str_logical 変換対象の列のデータタイプ（データ型）をロジカル型に変換します。引数の"true_value"に指定がない場合、"true", "Yes", "yes", "1"をTRUEに変換し、"false", "No", "no", "0"をFALSEに変換します。もし特定の値をTRUEにし、それ以外の値をFALSEにしたい場合は、true_valueにTRUEにしたい元の値を指定します。また、ロジカル型への変換対象の列が大文字、小文字が混在していたとしても、大文字、小文字は無視して文字列のみに注目してロジカル型への変換が行われます。
impute_na impute_naでは、平均値や中央値や最頻値、手動で指定した値、または線形回帰モデルによる予測値によって欠損値を埋めることができます。予測値を使って埋める場合は、予測変数の列を指定する必要があり、予測変数の列は複数指定が可能です。
get_mode 最も頻度の多い値を返します。
summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。
summarize_row 指定した集計関数を利用して、各行の列の値を集計 します。
mutate_group 表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。
confint_ratio 指定したロジカル型のデータからTRUEの割合の信頼区間（信頼区間の半分の幅）を返します。
calc_confint_ratio サンプルデータのサイズと標準偏差から、TRUEの割合の信頼区間（信頼区間の半分の幅）を返します。

Text

abbreviate 文字列をminlength文字に短縮し、一意にできるようにします。まず、文字列の先頭にある全てのスペースが削除されます。 その後、必要に応じて他のスペースが削除されます。次に、小文字の母音が (右から順に) 削除され、続いて小文字の子音が削除されます。最後に、省略形がminlengthよりも長い場合は、大文字が削除されます。
c いくつかの引数を組み合わせるための一般的な関数です。
iconv 指定されたテキストをあるエンコーディングから別のエンコーディングに変換します。
nchar 指定された値の文字数またはサイズを返します。
stri_compare 2つの文字列を比較し、辞書順で前後関係を判定します。結果は-1(先に位置する)、0(等しい)、1(後に位置する)の数値で返されます。
stri_datetime_format 指定された日時のフォーマットにもとづいて日付・時間型の列を文字列に変換します。
stri_escape_unicode 文字列の中の非ASCII文字（日本語などの多バイト文字や特殊記号）をUnicodeエスケープシーケンス（\uXXXX形式）に変換します。ASCII文字（英数字や基本的な記号）はそのまま保持されます。
stri_numbytes テキストデータが保存に必要なバイト数を返します。UTF-8エンコードでは、1文字が1-4バイトで表現されるため、文字数とバイト数は異なる場合があります。
stri_rand_strings 指定された長さのランダムな文字列を生成します。ASCII文字やUnicode文字など様々な文字種を使って生成できます。
str_c 複数のテキストや列をくっつけることができます。
str_conv テキストを指定されたエンコーディング（例：UTF-8）に変換します。
str_count テキストデータの文字数または単語数を返します。一致したパターンまたはテキストのみをカウントするように設定できます。
str_detect 特定の文字列が含まれているかどうかに基づいて、TRUEまたはFALSEを返します。
str_dup 文字列の値を繰り返します。
str_extract 指定した文字列または正規表現に一致する文字列を抽出します。
str_extract_all 指定した文字列または正規表現に一致する文字列をすべて抽出します。
str_length テキストデータの文字数を返します。
str_pad 指定した文字数に満たない空白箇所をスペース、または特定の文字で埋めることができます。
str_replace 指定した文字列または正規表現に一致する文字列を置き換えます。
str_replace_all 指定した文字列または正規表現に一致する文字列をすべて置き換えます。
str_replace_na 欠損値（NA）を特定の文字列に置換します。
str_split 指定した区切り文字によって、複数のテキストに分割します。値はリストとして返されるため、unnest() 関数で新しく作成された列のネストを解除する必要があります。
str_sub 位置に基づいて文字列を抽出します。
str_to_lower テキストを小文字に変換します。
str_to_title テキストをタイトルケースに変換します。
str_to_upper テキストを大文字に変換します。
str_trim テキストの中にある空白を取り除きます。
word テキストデータの最初、最後、またはN番目の単語を抽出します。
extract_numeric 指定されたテキストから数字のみを抽出します。数値以外のフォーマットがある文字列（例: $1,200.34, -12%, X1）に便利です。
url_parameters url からデコードされたクエリのパラメーターを返します。
coalesce 欠損値を特定の値または他の列の同じ位置にある値に置き換えます。
na_if 一致する値をNAに置き換えます。
recode 元の値を指定された値で置換します。数値の場合は数値にバックティックをつけるか、その位置に基づいて、置換ができます。文字列の場合は、その名前を置き換えることができます。
parse_number 文字列などを除いた上で数値のみを抽出し、Numeric（数値）型に変換します。
str_squish テキストの前後にある空白を削除し、テキスト中の連続した空白を単一の半角スペースに変換します。
str_trunc テキストの文字数が指定された数になるように、テキストを切り捨てます。
str_remove 指定した文字列または正規表現に一致する文字列を取り除きます。
str_remove_all 指定した文字列または正規表現に一致する文字列をすべて取り除きます。
str_remove_word 文章から単語を取り除きます。
str_replace_word 文章にある単語を指定して単語に置換します。
str_remove_inside 指定した文字の範囲内に含まれる文字を取り除きます。
str_replace_inside 指定した文字の範囲内に含まれる文字を置換します。
str_remove_url 文字列の中にあるURLを取り除きます。
str_replace_url 文字列の中のURLを指定したテキストに置換します。
str_extract_url 文字列の中からURLを抽出します。
str_remove_emoji 文字列の中から絵文字を取り除きます。
anonymize ハッシュ・アルゴリズムによって値を匿名化します。
str_remove_before 指定した区切り文字または正規表現に一致する箇所より前の文字列を取り除きます。
str_remove_after 指定した区切り文字または正規表現に一致する箇所より後ろの文字列を取り除きます。
str_remove_range テキストデータから指定した範囲の文字を取り除きます。
str_replace_before 指定した区切り文字または正規表現に一致する箇所より前の文字列を、指定した文字列に置き換えます。
str_replace_after 指定した区切り文字または正規表現に一致する箇所より後ろの文字列を、指定した文字列に置き換えます。
str_replace_range テキストデータの指定した範囲の文字を、別の文字列に置き換えます。
str_extract_before 指定した区切り文字または正規表現に一致する箇所より前の文字列を抽出します。
str_extract_after 指定した区切り文字または正規表現に一致する箇所より後ろの文字列を抽出します。
str_extract_inside 指定した文字や記号の中のテキストを抽出することができます。抽出される文字列が複数ある場合はlist型となるため、list_to_text関数で囲ってください。
str_clean エスケープ文字（例: \n, \t）、余分な空白、余分なピリオド、先頭と末尾のスペースを削除して、テキストをきれいにします。
str_count_all 文字列のパターンを数えます。
str_normalize 全角のアルファベット、数字、特殊文字を通常のアルファベット、数字、特殊文字に置き換えます。また半角カナ文字を全角カナ文字に置き換え、その他の正規化規則を適用してテキストを正規化します。これはUnicode 正規化形の規則に従います。なお、この関数はstringi::stri_trans_nfkc 関数のラッパー関数です。
str_logical 変換対象の列のデータタイプ（データ型）をロジカル型に変換します。引数の"true_value"に指定がない場合、"true", "Yes", "yes", "1"をTRUEに変換し、"false", "No", "no", "0"をFALSEに変換します。もし特定の値をTRUEにし、それ以外の値をFALSEにしたい場合は、true_valueにTRUEにしたい元の値を指定します。また、ロジカル型への変換対象の列が大文字、小文字が混在していたとしても、大文字、小文字は無視して文字列のみに注目してロジカル型への変換が行われます。
get_stopwords "a"、"the"、"and"などのストップワードを返します。
word_to_sentiment 単語に対して、肯定的または否定的なセンチメントの種類を返します。
get_sentiment 文章からセンチメントスコアを返します。正のスコアは肯定的な文章を表し、負のスコアはその反対を表します。0は「中立」を意味します。
stem_word 綴りが若干異なる単語を同じ単語として認識できるように整えます。
is_stopword 文字列に辞書で定義されたストップワードのリストに含まれる単語がある場合、TRUEを返します。
is_empty 文字列が空文字または NAのときにTRUEを返します。
is_alphabet 文字列がアルファベットのみを含む場合に TRUE を返します。
ip_to_country IPアドレスから国名を返します。
url_domain url からドメイン (例: "exploratory.io")を返します。
url_fragment url からフラグメントを返します。
url_path urlからパスを返します。
url_port url からポートを返します。
url_scheme urlからスキーム（例："http"、"https"）を返します。
url_suffix urlから接尾辞（例："com"、"org"）を返します。
url_subdomain urlからサブドメイン (例 "www", "blog") を返します。
url_tld url からトップレベルドメイン (例 "com"、"co") を返します。
url_param url からデコードされたクエリパラメーターを返します。
countrycode 国名や国名コードを他の形式の国コードや名前（国名、大陸名、地域名など）に変換します。国際的なデータ分析やレポート作成時に、異なるデータソースの国コードを統一するのに役立ちます。
statecode 米国の州の情報を持つ列から、米国の州名、略称、数値コード、区分、地域のいずれかを返します。州の情報は、米国の州名、略語 (FIPS / ANSI コード)、数値コード (FIPS) のいずれかであり、任意の組み合わせが可能です。
countycode 米国の州および郡名にをもとに米国の郡コード（FIPS - 連邦情報処理標準）を生成します。
impute_na impute_naでは、平均値や中央値や最頻値、手動で指定した値、または線形回帰モデルによる予測値によって欠損値を埋めることができます。予測値を使って埋める場合は、予測変数の列を指定する必要があり、予測変数の列は複数指定が可能です。
get_mode 最も頻度の多い値を返します。
summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。
summarize_row 指定した集計関数を利用して、各行の列の値を集計 します。
mutate_group 表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。
str_conv_zenhan 文字列内の全角文字と半角文字を変換します。また、文字列内の半角文字を全角文字に変換します。
str_conv_hirakana 文字列内のひらがなとカタカナを相互に変換します。
separate_japanese_address 日本の住所文字列を都道府県、市区町村、町名番地に分割します。
convert_jyear 和暦年（令和、平成、昭和など）を西暦年に変換します。元号の漢字表記（令和三年）とアルファベット表記（R3）の両方に対応しています。
convert_prefecture 都道府県名を漢字形式（例: 東京都）またはローマ字形式（例: Tokyo-to）に相互変換します。住所データの正規化や標準化に利用できます。
convert_prefecture_from_kana ひらがなまたはカタカナで表記された都道府県名を漢字表記に変換します。住所データの正規化や名寄せ処理に利用できます。
harmonize_prefecture_name 都道府県名の表記を統一された形式に変換します。「都」「府」「県」の有無や、略称・正式名称の違いを吸収して、一貫性のある表記に揃えることができます。
is_zipcode 文字列が日本の郵便番号として正しい形式かどうかを判定します。7桁の数字のみの形式とハイフン区切りの形式の両方に対応しています。
str_jconv 日本語の文字種（ひらがな、カタカナ、全角、半角など）を相互に変換します。変換関数と変換先の形式を指定することで、様々な文字種の変換に対応できます。
str_jnormalize 文字列を正規化された形式に変換します。全角英数字の半角化、空白文字の統一、重複する空白の削除などを行います。
zipcode_spacer 郵便番号の形式を整形します。数字のみの形式とハイフン付きの形式を相互に変換できます。データの標準化や表示形式の統一に利用できます。
kansuji2arabic_num 漢数字（一、二、三など）をアラビア数字の文字列（1、2、3など）に変換します。この関数は数値ではなく文字列を返すため、数値として扱いたい場合は`as.numeric`関数と組み合わせる必要があります。

Number

abs 数値を絶対値として返す。
acos 逆余弦の値をラジアン単位で返します。
acosh 逆双曲線余弦の数値を返します。
asin 逆正弦の値をラジアン単位で返します。
asinh 逆双曲線正弦の数値を返します。
atan 逆正接の値をラジアン単位で返します。
atan2 x軸と原点（0,0）から指定された座標ペア (`x`,`y`) までの線分との間の角度をラジアン単位で返します。
atanh 逆双曲線正接の数値を返します。
ceiling 数値を整数または指定した小数点で切り上げる。
cos 指定された角度のコサインをラジアン単位で返します。
cosh 任意の実数の双曲線余弦を返します。
cospi cos(pi * )を返します。
cut 数値を指定した数に分割し、その間隔の値（下限,上限）を返します。
exp ネイピア数（オイラー数）のe（~2.718）の累乗を返します。
floor 数値を整数または指定した小数点で切り捨てる。
log 対数を返します。デフォルトは自然対数での値を返します。
log10 常用対数（10を底とする対数）を返します。
log1p log(1+数値) の値を返します。数値がゼロに近い場合でも、正確な値が計算できます。
log2 二進対数（2を底とする対数）を返します。
pmax 並列する値のうち、どちらかの最大値を返します。
pmin 並列する値のうち、どちらかの最小値を返します。
round 数値を整数または指定した小数点で四捨五入する。
sign 値が正、0、または負であるかどうかに応じて、それぞれ1、0、-1を返します。
signif 値を指定した有効桁数に四捨五入します。
sin 指定された角度のサインをラジアン単位で返します。
sinh 任意の実数の双曲線正弦を返します。
sinpi sin(pi * )を返します。
sqrt 値の平方根を返します。
tan 指定された角度のタンジェントをラジアン単位で返します。
tanh 任意の実数の双曲線正接を返します。
tanpi tan(pi * )を返します。
trunc 数値の小数点以下を切り捨てます。
coalesce 欠損値を特定の値または他の列の同じ位置にある値に置き換えます。
near 2つの数値ベクトルを比較します。浮動小数点数の2つのベクトルが（対で）等しいかどうかを比較する安全な方法です。許容誤差が組み込まれている点におい、== を使うよりも安全です。
recode 元の値を指定された値で置換します。数値の場合は数値にバックティックをつけるか、その位置に基づいて、置換ができます。文字列の場合は、その名前を置き換えることができます。
normalize 列の数値を標準化を行います。標準化後のデータは、平均値が0、標準偏差が1になります。
impute_na impute_naでは、平均値や中央値や最頻値、手動で指定した値、または線形回帰モデルによる予測値によって欠損値を埋めることができます。予測値を使って埋める場合は、予測変数の列を指定する必要があり、予測変数の列は複数指定が可能です。
detect_outlier 外れ値を検出し、'upper'（上位）ラベルと'lower'（下位）ラベルを返します。
get_mode 最も頻度の多い値を返します。
summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。
summarize_row 指定した集計関数を利用して、各行の列の値を集計 します。
mutate_group 表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。
confint_mean 与えられた数値データから、平均の信頼区間（信頼区間の半分の幅）を返します。
calc_confint_mean サンプルデータのサイズと標準偏差から、平均の信頼区間（信頼区間の半分の幅）を返します。
cumsum_decayed 減衰効果の累積和を計算します。第二引数のRが1の場合は、cumsum関数と同じ結果を得られます。
ts_lag 特定の値の指定した前期間の値を返します。
ts_diff 特定の値の指定した前期間との差を計算します。
ts_diff_ratio 特定の値の指定した前期間との差の割合を計算します。
likert_sigma 1="強くそう思わない"、2="そう思わない"、3="どちらでもない"、4="そう思う"、5="強くそう思う "のようなアンケートの回答データの列からリッカートのシグマ値を返します。
logistic 数値列に対してロジスティック関数を適用した結果を返すことができます。

Aggregate

all 行またはグループ内の行ですべての行が指定した条件を満たす場合、TRUEを返します。
any 行またはグループ内の行で指定した条件を満たすものが一つでもある場合、TRUEを返します。
length 値の長さを返します。
max すべての値の最大値を返します。
mean すべての値の平均値を返します。
min すべての値の最小値を返します。
prod 指定されたデータの一連の数値を乗算して積値を返します。
sum すべての値の合計値を返します。
unique 一意な値の数を返します。
n 各グループの行数を返します。
n_distinct 一意な値の数を返します。
nth n番目の値を返します。
IQR 四分位範囲を計算します。
mad 中央絶対偏差を計算します。
median 中央値を計算します。
quantile 与えられた確率に対応する標本の分位数を計算します。最小値は確率0に対応し，最大値は確率1に対応します。
sd 標準偏差を計算します。
var 分散を計算します。
get_mode 最も頻度の多い値を返します。
summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。
sum_if 指定した条件を満たす合計値を返します。
sum_if_ratio 指定した条件を満たす合計値の、すべての値の合計値に対する比率を返します。
count_if 指定した条件を満たす行の数を集計します。
count_if_ratio 総行数に対する指定した条件を満たす行の数の比率を集計します。
count_unique_if 指定した条件を満たす行に由来する列の一意な値の数を数えます。
count_unique_if_ratio 指定した条件を満たす行から得られる一意の値の数と、一意の値の数の比率を返します。
mean_if 指定した条件を満たす平均値を返します。
average_if 指定した条件を満たす平均値を返します。 average_if関数は mean_if のエイリアスです。
median_if 指定した条件を満たす中央値を返します。
max_if 指定した条件を満たす数値列の最大値を返します。
min_if 指定した条件を満たす行の中から、数値列の場合は最小値、日付の列の場合は最初の日を返します。例えば、特定の製品カテゴリでの最小の販売価格や、特定の製品を購買した最初の日を取得する際に使用できます。
count_rows グループごとの行の数を集計します。
count_unique 一意な値の数を返します。

Type Conversion

as.character データタイプを文字列型（Character）に変換します。
as.Date データタイプを日付型（Date）に変換します。日付型のデータには時間の情報は含まれません。デフォルトのフォーマットは「2020-01-01」と表現するISO8601の国際規格に従います。
as.double データタイプを不動小数点型（double）に変換します。数値型（Numeric）と同じ挙動になります。
as.factor 指定した列をFactor型に変換します。
as.integer データタイプを整数型（integer）に変換します。
as.logical 変換対象の列をロジカル型（TRUE/FALSE）に変換します。数値の場合は0がFALSE、0以外の値がTRUEに変換されます。文字列の場合は"TRUE"、"True"、"true"、"T"、"t"がTRUEに、"FALSE"、"False"、"false"、"F"、"f"がFALSEに変換されます。それ以外の文字列はNAになります。
as.numeric データタイプを数値型（Numeric）に変換します。
as.POSIXct データタイプを日付・時間型（POSIXct）に変換します。
factor レベル（順序）を指定して、列をFactor型に変換します。
parse_date_time データを日付時間型に変換します。
stri_datetime_format 指定された日時のフォーマットにもとづいて日付・時間型の列を文字列に変換します。
parse_number 文字列などを除いた上で数値のみを抽出し、Numeric（数値）型に変換します。
parse_double データをDouble（倍精度浮動小数点数）型に変換します。
parse_euro_double データをDouble（倍精度浮動小数点数）型に変換します。
parse_integer データをInteger（整数）型に変換します。
parse_time 時刻型の文字列をhms（時刻）型に変換します。
parse_character データをCharacter（文字列）型に変換します。
parse_factor データをFactor（順序付きカテゴリー）型に変換します。
parse_logical データをLogical（論理値）型に変換します。
as_date POSIXct型の列をDate型に変換できます。
as_datetime データをPOSIXct型に変換します。
as.hms 指定されたデータをhms型のデータに変換します。Hms,difftimeの値を計算で使う際には秒単位で処理されます。
excel_numeric_to_date Excelの日付の数値（例: 42370）を日付型（例: 2016-01-01）に変換します。
excel_numeric_to_datetime Excelで数値になっている日付/時刻の値をPOSIXct型の値に変換します。
unixtime_to_datetime unix時間の数値をPOSIXctに変換します。
str_logical 変換対象の列のデータタイプ（データ型）をロジカル型に変換します。引数の"true_value"に指定がない場合、"true", "Yes", "yes", "1"をTRUEに変換し、"false", "No", "no", "0"をFALSEに変換します。もし特定の値をTRUEにし、それ以外の値をFALSEにしたい場合は、true_valueにTRUEにしたい元の値を指定します。また、ロジカル型への変換対象の列が大文字、小文字が混在していたとしても、大文字、小文字は無視して文字列のみに注目してロジカル型への変換が行われます。

Others

chartr oldで指定された各文字を、newで指定された対応する文字に変換します。
list リストを作成します。
rep 指定された値を繰り返し複製します。
rev 指定されたデータの要素の順序を逆転します。
desc 並び替え（ソート）の順序を降順に変更します。例えば、1から9の代わりに9から1へ、aからzの代わりにzからaへといった順序になります。

Window Calculation

cummax 累積最大値を返します。
cummin 累積最小値を返します。
cumprod 累積積を返します。
cumsum 累積合計値を返します。
cumall 現在の位置までのすべての値がTRUE のときにTRUE を返します。
cumany 現在の位置までの値のいずれかが TRUE ならば TRUE を返します。
cume_dist その値の順位以下の全値の割合である累積分布を返します。欠測値の場合は、欠損値を返します。
cummean 累積平均を返します。
dense_rank 隙間のない順位を返します。 欠損値の場合は、欠損値がそのまま残ります。
first 最初の値を返します。
lag 注目している値より前の値を返します。
last 最後の値を返します。
lead 注目している値よりも後の値を返します。
min_rank 隙間のある順位を返します。同じ順位のときには、最小の順位を返します。 欠損値の場合は、欠損値がそのまま残ります。
ntile データを指定した数（n）のグループに「等頻度」（各グループの行数がほぼ同じ）になるように分割し、各行がどのグループに属するかを示す整数値（1からnまで）を返します。この「等頻度での分割」は、分けられた各グループの行数が均等になるように分けるため、等幅（同じ数値の幅）での分割とは異なる処理であることに注意が必要です。
percent_rank 0から1間で順位比率を返します。 欠損値の場合は、欠損値がそのまま残ります。
row_number 行番号を返します。
roll_max 移動計算により、指定されたウィンドウサイズ間の最大値を返します。
roll_mean 移動計算により、指定されたウィンドウサイズ間の平均値を返します。
roll_median 移動計算により、指定されたウィンドウサイズ間の中央値を返します。
roll_min 移動計算により、指定されたウィンドウサイズ間の最小値を返します。
roll_prod 移動計算により、指定されたウィンドウサイズ間の積値を返します。
roll_sd 移動計算により、指定されたウィンドウサイズ間の標準偏差を返します。
roll_sum 移動計算により、指定されたウィンドウサイズ間の合計値を返します。
roll_var 移動計算により、指定されたウィンドウサイズ間の分散を返します。
mutate_group 表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。

Date

difftime 指定された2つの日付・時間の差を計算します。
months 計算に使用できるように、数値を月の単位に変換します。
ceiling_date 日付・時間を、指定した単位に最も近い日付、または時間に切り上げます。
date_decimal 年の分数である数値データを日付データに変換します。
day 日付型や日付時間型の値から日の情報を抽出します。
days 計算に使用できるように、数値を日の単位に変換します。
decimal_date 日付を年の分数に計算し、日付データを数値データに変換します。
dmy 日、月、年の順番の文字列または数値データを日付型に変換します。
dmy_h 日、月、年、時の順番の文字列のデータを日付時間型に変換します。
dmy_hm 日、月、年、時、分の順番の文字列のデータを日付時間型に変換します。
dmy_hms 日、月、年、時、分、秒の順番の文字列のデータを日付時間型に変換します。
duration 数値と指定した単位をもとに、秒単位に換算した値を求められます。
dym 日、年、月の順番の文字列または数値データを日付型に変換します。
floor_date 日付・時間を、指定した単位に最も近い日付、または時間に切り捨てます。
force_tz 指定したタイムゾーンに修正します。
here 設定されているローカルのタイムゾーンの現在時刻を取得します。
hm 時と分のデータを期間のデータ型（Period）に変換します。
hms hms型のデータを作成できます。Hms,difftimeの値を計算で使う際には秒単位で処理されます。
hour 日付型や日付時間型の値から時間の情報を抽出します。
hours 計算に使用できるように、数値を時間の単位に変換します。
interval 2つの日付間の間隔を秒単位で返します。この結果を使用して、日、週などの特定の単位で除算するか、as.numeric()で数値型に変換することで期間を取得できます。
isoweek 年の週番号を抽出します。週の開始曜日は月曜日になっています。
mday 日付列から月の日（1-31）を抽出します。
mdy 月、日、年の順番の文字列または数値データを日付型に変換します。
mdy_h 月、日、年、時の順番の文字列のデータを日付時間型に変換します。
mdy_hm 月、日、年、時、分の順番の文字列のデータを日付時間型に変換します。
mdy_hms
milliseconds 数値をミリ秒に変換してPeriod型として値を返します。
minute 日付型や日付時間型の値から分の情報を抽出します。
minutes 計算に使用できるように、数値を分の単位に変換します。
month 日付型や日付時間型の値から月の情報を抽出します。
ms 分と秒のデータを期間のデータ型（Period）に変換します。
myd 月、年、日の順番の文字列または数値データを日付型に変換します。
parse_date_time データを日付時間型に変換します。
qday 日付列から四半期の最初の日からの日数（1-92）を抽出します。
quarter 日付型や日付時間型の値から四半期の情報を抽出します。
rollback 日付データを前月の末日、またはその月の最初の日に丸め処理します。
round_date 日付・時間を、指定した単位に最も近い日付、または時間に丸めます。
second 日付型や日付時間型の値から秒の情報を抽出します。
seconds 計算に使用できるように、数値を秒の単位に変換します。
time_length 2つの日付間の正確な期間を計算して数値として値を返します。
today 今日の日付を返します。似た関数に'now()'があり、now関数は現在時刻含む今日の日付を返します。
wday 日付列から曜日（1-7）を数値（例: 月曜日は1）、または文字列（例: 日曜日）として返します。文字列はショート（例: 日）、またはロング（例: 日曜日）として返すことができます。
week 日付型や日付時間型の値から1年の週番号を抽出します。第1週の1日目は、曜日に関係なく、常に1月1日から始まります。
weeks 計算に使用できるように、数値を週の単位に変換します。
with_tz 指定したタイムゾーンでの日付・時間を返します。
yday 日付列から年の日（1-366）を抽出します。
ydm 年、日、月の順番の文字列または数値データを日付型に変換します。
ydm_h 年、日、月、時の順番の文字列のデータを日付時間型に変換します。
ydm_hm 年、日、月、時、分の順番の文字列のデータを日付時間型に変換します。
ydm_hms
year 日付型や日付時間型の値から年の情報を抽出します。
years 計算に使用できるように、数値を年の単位に変換します。
ymd 年、月、日の順番の文字列または数値データを日付型に変換します。
ymd_h 年、月、日、時の順番の文字列のデータを日付時間型に変換します。
ymd_hm 年、月、日、時、分の順番の文字列のデータを日付時間型に変換します。
ymd_hms 年、月、日、時、分、秒の順番の文字列のデータを日付時間型に変換します。
coalesce 欠損値を特定の値または他の列の同じ位置にある値に置き換えます。
recode 元の値を指定された値で置換します。数値の場合は数値にバックティックをつけるか、その位置に基づいて、置換ができます。文字列の場合は、その名前を置き換えることができます。
parse_time 時刻型の文字列をhms（時刻）型に変換します。
ym 年、月の順番の文字列または数値データを日付型に変換します。
my 月、年の順番の文字列または数値データを日付型に変換します。
yq 年と四半期の文字列データを日付型に変換します。
epiweek 年の週番号を抽出します。週の開始曜日は日曜日になっています。
as_date POSIXct型の列をDate型に変換できます。
as.hms 指定されたデータをhms型のデータに変換します。Hms,difftimeの値を計算で使う際には秒単位で処理されます。
impute_na impute_naでは、平均値や中央値や最頻値、手動で指定した値、または線形回帰モデルによる予測値によって欠損値を埋めることができます。予測値を使って埋める場合は、予測変数の列を指定する必要があり、予測変数の列は複数指定が可能です。
get_mode 最も頻度の多い値を返します。
summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。
summarize_row 指定した集計関数を利用して、各行の列の値を集計 します。
mutate_group 表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。
weekend 指定した日付列の値をもとに、平日か週末かのラベルをつけます。
is_japanese_holiday is_jholiday関数のエイリアスです。指定した日付が日本の祝日の場合、TRUEを返します。
get_week_of_month 月の週を抽出します。例えば、指定した日付が月の第1週であれば `1` を返します。
years_between 2つの日付間の期間を年数で計算します。
months_between 2つの日付間の期間を月数で計算します。
weeks_between 2つの日付間の期間を週数で計算します。
days_between 2つの日付間の期間を日数で計算します。
hours_between 2つの日付間の期間を時間で計算します。
minutes_between 2つの日付間の期間を分で計算します。
seconds_between 2つの日付間の期間を秒で計算します。
last_date 指定した単位（月など）における、最後の日付を返します。
ts_lag 特定の値の指定した前期間の値を返します。
ts_diff 特定の値の指定した前期間との差を計算します。
ts_diff_ratio 特定の値の指定した前期間との差の割合を計算します。
is_jholiday 指定された日付が日本の祝日だった場合にTRUEを返します。
convert_jdate 日本の和暦形式の文字列（例: 令和3年1月1日、R3/1/1）を西暦形式の日付（例: 2021-01-01）に変換します。
find_date_by_wday 指定した年月の特定の曜日の日付を取得します。例えば、「2023年5月の第3火曜日」のような指定が可能です。祝日設定や定期的なスケジュール管理に便利です。

Data Frame

intersect 複数のデータフレームに共通して存在する行のみを抽出します。集合演算の「積集合」に相当します。
setdiff 最初のデータフレームにあり、2番目以降のデータフレームにない行のみを抽出します。集合演算の「差集合」に相当します。
union 複数のデータフレームを結合し、どちらかまたは両方のデータフレームに存在する行を保持します。集合演算の「和集合」に相当します。
anti_join 現在のデータフレームから、ターゲットのデータフレームに一致する値がない行のみを返します。現在のデータフレームの列だけを保持します。
arrange 指定した列の値に基づいて行をソートします。デフォルトでは昇順（小さい値から大きい値）でソートします。
bind_cols 複数のデータフレームを列方向に結合します。結合するデータフレームの行数が同じである必要があります。
bind_rows 複数のデータフレームを行方向に結合します。列名が共通のものは自動的に一致させて結合されます。
distinct 重複する行を削除し、ユニークな行のみを保持します。デフォルトでは最初に現れた行のみが残されます。.keep_all引数をTRUEに設定すると、指定した列でユニークな行のすべての列を保持できます。
filter 条件に基づいてデータフレームから行を選択します。
full_join 現在のデータフレームとターゲットのデータフレームの両方からすべての行とすべての列を返します。結合に一致しない場合、欠損値（NA）が使われます。これは外部結合（FULL OUTER JOIN）と呼ばれる操作です。
group_by データフレームをグループ化されたデータフレームに変換します。グループ化すると、それ以降の操作がグループごとに実行されます。集計操作を行う前にグループ化する必要があります。
inner_join 現在のデータフレームと対象データフレームの両方に一致する値がある行だけを返します。現在のデータフレームと対象データフレームの両方の列が返されます。これはSQL文の「INNER JOIN」に相当します。
left_join 左外部結合（LEFT JOIN）を実行します。現在のデータフレーム（左側）のすべての行と、現在のデータフレームとターゲットデータフレーム（右側）からすべての列を返します。左側のデータフレームの行に右側のデータフレームで一致するものがない場合、右側から追加される列にはNA値が入ります。複数の一致がある場合は、すべての組み合わせが返されます。
mutate mutate関数は、既存の列を保持したまま、指定した式に基づいて新しい列を作成します。複数の列を一度に作成することも可能です。既存の列を削除しながら新しい列を作成したい場合は、transmute関数を代わりに使用できます。
rename データフレーム内の既存の列名を変更します。複数の列名を一度に変更することも可能です。
right_join 結合先のデータフレームの全ての行と、現在のデータフレームおよび結合先の全ての列を返します。結合先のデータフレームにおいて現在のデータフレームに一致する値がない行では、現在のデータフレームの列にNA値が入ります。left_joinの逆の動作をします。
sample_frac sample_frac関数は、データフレームからランダムな割合の行をサンプリングします。例えば、データの20%をランダムに抽出したい場合などに使用します。
sample_n sample_n関数は、データフレームから指定した行数をランダムにサンプリングします。例えば、データから100行をランダムに抽出したい場合などに使用します。
select データフレームから指定した列を選択します。列名を直接指定する以外にも、starts_with()、ends_with()、contains()などの関数を使って列を選択することができます。不要な列を除外するために、列名の前にマイナス記号（-）をつけることもできます。
semi_join 結合先のデータフレームに一致する値がある現在のデータフレームの行だけを返します。返される列は現在のデータフレームの列だけで、結合先のデータフレームの列は含まれません。inner_joinとは異なり、一致する行が複数あっても重複は発生しません。
slice 行の位置を指定してデータフレームから行を選択します。
summarize 列の値を集計関数を使って単一の値にまとめます。一般的にgroup_by()と組み合わせて使用し、グループごとの統計量を計算します。
top_n top_n関数は、指定した列の値に基づいて、各グループの上位（または下位）n個のデータに絞り込むことができます。
transmute 新しい列を追加しながら既存の列を削除します。mutate関数と異なり、明示的に指定した新しい列だけが結果に含まれます。既存の列を保持したまま新しい列を追加したい場合は、mutate関数を使用します。
ungroup group_by関数で設定されたグループ化を解除します。グループ化されたデータフレームに対して操作を行った後、グループ化を解除するために使用されます。
predict 予測値や残差などのモデルの性能評価や診断に役立つ情報を返します。
complete 欠損しているデータの組み合わせを追加したデータフレームを返します。
expand 指定した列のすべての組み合わせを追加して、データフレームを拡張します。
fill 欠損値（NA）を前の行または後の行の値で埋めます。特に、データが省略されている場合に、同じグループ内で値を補完するのに便利です。
nest 一連の列をリスト列としてネスト（入れ子）化します。
nesting 複数の列を取り、それらをキー・バリューのペアに変換します。その際、他のすべての列は必要に応じて複製されます。
separate 区切り文字を含む列を複数の列に分割します。
spread キー・バリューのペアを複数の列に展開します。欠損値はNAで置き換えられます。
unite 複数の列を1つの列に結合します。デフォルトでは、値を"_"で連結し、元の列を削除します。リストで指定された複数の列を一度に結合できます。
unnest リスト列またはデータフレームのリストを展開し、リストの各要素が独自の行に表示されるようにします。
select_if
rename_with 関数を適用して、複数の列名を一括変換します。
mutate_all mutate_all関数は、データフレームのすべての列に対して関数を適用します。すべての列に同じ変換を適用したい場合に便利です。
mutate_at 指定した列に対して関数を適用します。vars()を使用して列を選択し、その列に対して特定の変換を適用できます。
mutate_if 条件に一致する列にのみ関数を適用します。条件はTRUEまたはFALSEを返す関数で指定します。
summarize_all データフレームのすべての列に対して集計関数を適用します。一般的にgroup_by()と組み合わせて使用し、グループごとのすべての列の統計量を計算します。
summarize_at 指定した列に対して集計関数を適用します。特定の列のみに集計操作を行いたい場合に便利です。
summarize_if summarize_if関数は、条件に一致する列にのみ集計関数を適用します。例えば、数値型の列だけに対して平均値を計算するなどの操作が可能です。
separate_rows 区切り文字を含む列を複数の行に分割します。
unnest_wider リスト列の各要素を列に変換して展開します。
unnest_longer リスト列の各要素を行に変換して展開します。
hoist リスト列のコンポーネントを選択的に取り出して、トップレベルの列として表示します。
drop_na NA値を持つ行を削除します。
type_convert Heuristically guess the data type for each column by reading the first 1000 rows, parse the data, and set appropriate data types for all the columns of the data frame.
model_info Returns a summary information of a given model in a tidy (normalized data frame) format.
clean_names 列名をアンダースコア（_）、小文字のアルファベット、数字のみを使用してきれいな列名の形式に変換します。
get_dupes 指定した列（複数可）で重複している行を抽出します。何も指定しない場合、全ての列で重複している行を対象とします。
tabyl 指定した列の頻度表を作成します。データの分布を素早く把握するのに役立ちます。パーセント表示やNA値の処理にも対応しています。
do_svd.kv SVD(特異値分解)を使用して次元削減を行い、座標を計算します。
do_svd SVD(特異値分解)を使用して次元削減を行い、座標を計算します。
build_lm 線形回帰モデル(lm)を作成し、データフレームに格納します。
build_lr ロジスティック回帰モデルを作成し、データフレームに格納します。
build_glm 一般化線形モデル(glm)を作成し、データフレームに格納します。
build_multinom 多項ロジスティック回帰モデルを作成し、データフレームに格納します。
prediction モデルについての回帰情報を含むデータフレームを返します。
prediction_binary モデルについての二値分類情報を含むデータフレームを返します。
prediction_coxph Cox比例ハザードモデルの予測値を含むデータフレームを返します。
model_coef モデルの「パラメータ推定（係数）」に関する以下の情報を含むデータフレームを返します。* term - 推定された項（変数）* estimate - 推定された係数。数値が大きいほど、その変数の影響が正の方向に強いことを示します。* std_error - 標準誤差。その変数の予測誤差の大きさを示します。* t_ratio - estimate / std_error。この値のt分布における確率がp_valueとなります。* p_value - その変数が「効果がない」確率。* conf_low - 信頼区間の下限。* conf_high - 信頼区間の上限。
model_stats モデルについての「フィット概要」情報を含むデータフレームを返します。返される情報には以下が含まれます。* r_square - 決定係数（R²）* r_square_adj - 自由度調整済み決定係数* root_mean_square_error - 平均二乗誤差の平方根* f_ratio - F比* p_value - P値* df - 自由度* null_deviance - ヌル逸脱度* df_for_null_model - ヌルモデルの自由度* log_likelihood - 対数尤度* deviance - 逸脱度* AIC - 赤池情報量基準* BIC - ベイズ情報量基準* residual_df - 残差の自由度
model_anova モデルについての分散分析（ANOVA）の検定情報を含むデータフレームを返します。返される情報には以下が含まれます。* df - 自由度* sum_of_squares - 平方和* mean_square - 平均平方* f_ratio - F比* p_value - P値* deviance - 逸脱度* residual_df - 残差の自由度* residual_deviance - 残差逸脱度
evaluate_regression
evaluate_binary 二値分類のモデルの評価を含むデータフレームを返します。含まれる指標は以下の通りです。* AUC* f_score* accuracy* misclassification_rate* precision* recall* specificity* true_positive* false_positive* true_negative* false_negative* test_size* threshold
evaluate_multi 多クラス分類のモデルの評価を含むデータフレームを返します。含まれる指標は以下の通りです。* micro_f_score* macro_f_score* accuracy* misclassification_rate
do_roc ROCカーブの座標を返します。ROC（Receiver Operating Characteristic）カーブは、二値分類のモデルの精度を評価するための曲線で、閾値の変更に伴う真陽性率と偽陽性率を可視化したものです。
build_kmeans.cols K-Meansクラスタリングのモデルを構築し、モデルの要約または拡張されたデータを返します。
build_kmeans.kv K-Meansクラスタリングのモデルを構築し、生成されたデータフレームにモデルを格納、またはクラスターIDで元のデータを拡張します。
build_kmeans K-Meansクラスタリングのモデルを構築します。モデルは生成されたデータフレームに格納されるか、パラメータ値に応じて元のデータに追加されます。
do_t.test t検定を実行し、変数の平均値の差を検証します。
do_var.test F検定を実行し、グループ間の分散の差を検証します。
do_chisq.test カイ二乗分割表検定と適合度検定を実行します。
do_apriori トランザクションデータから同時に発生する傾向のあるアイテムのルールを見つけます。これは主に購買データの分析やアソシエーション分析に使用され、「どの商品が一緒に購入される傾向があるか」などのインサイトを得られます。
do_anomaly_detection 時系列データの異常値を検出します。
do_prophet 時系列のデータフレームに予測値を追加します。Facebook開発のProphetアルゴリズムを使用して将来のトレンドを予測します。
do_market_impact 合成対照群（synthetic control）を形成するために他の市場を使用して、市場にイベント（広告など）の影響を推定します。これは、特定の市場で行われた介入（マーケティングキャンペーンなど）の効果を分析するのに役立ちます。
row_as_header 指定した行を列名として使用します。
pivot 行と列にピボットします。値は行と列のペアの数や、別の列の集計です。データの再構成やクロス集計表を作成する際に便利です。
do_cor.cols すべての変数（列）のペアの相関を計算します。
do_cor.kv 選択列の全てのペアの組み合わせの相関係数を計算します。
do_cor 選択した変数の値のペアについて相関係数を計算します。
do_dist.kv 各ペア間の距離を計算します。キー列を次元、値列を値として使用し、様々な距離計算手法から選択できます。
do_dist.cols 各ペア間の距離を計算します。列をベクトルとして扱い、指定した距離計算手法に基づいて列間の距離を算出します。
do_dist 指定した変数の全てのペアについて距離を計算します。
do_cmdscale 多次元尺度法（MDS）を実行します。エンティティのペア間の距離から近似的な座標を計算します。これにより高次元データを視覚化しやすい低次元空間（通常は2次元や3次元）に射影できます。
build_model 入力データフレームからモデル関数と引数によってモデルを含むデータフレームを作成します。
one_hot カテゴリカルデータの列をワンホットエンコーディングし、それぞれのカテゴリに対応する新しい列を作成します。新しい列は、行がそのカテゴリに該当する場合は1、それ以外は0を持ちます。
sample_rows データフレームからn行をサンプリングします。sample_n関数と似ていますが、指定された行数がデータの行数より多い場合にエラーを発生させずに処理できる点が異なります。
exp_balance SMOTE（Synthetic Minority Oversampling Technique）を使用して、不均衡なデータをバランスの取れたデータに変換します。少数派の合成データを作成し、多数派クラスのデータを適切に調整することで、バイアスのない機械学習モデルを構築しやすくします。対象となる列は0/1 の数値、または 2 値のカテゴリデータ、ロジカル型の列に限定されます。

Factor

levels 指定されたFactor型のレベルを返します。
coalesce 欠損値を特定の値または他の列の同じ位置にある値に置き換えます。
recode 元の値を指定された値で置換します。数値の場合は数値にバックティックをつけるか、その位置に基づいて、置換ができます。文字列の場合は、その名前を置き換えることができます。
as_factor 指定した列を順序付きカテゴリーの列に変換します。標準搭載のbase関数のas.factor との違いは、出現する順序でレベルを作成する点です。またすべてのプラットフォームで同じ挙動です。 (base関数はロケールでソートするため、環境に応じて結果が変わる可能性があります)
fct_anon 順序付きカテゴリーのレベルを匿名化し、任意の数値に置き換えます。値もレベルの順序も保持されません。
fct_expand ファクター型の列にレベルを追加します。
fct_drop ファクター型の列から不要なレベルを削除します。
fct_explicit_na 欠損値にレベルが与えられ、欠損値がカテゴリーとして確実にチャートで表示されるようになります。
fct_lump データタイプをfactor型にし、値の出現頻度に応じて、出現頻度が低い値を「Other」グループにします。
fct_other 指定した値を「Other」グループにまとめる、または指定した値以外を「Other」グループにまとめることができます。
fct_inorder 元のデータ順に基づき値に順序をつけ、データタイプをfactor型に変換します。
fct_infreq 値の頻度をもとに順序をつけ、データタイプをfactor型に変換します。
fct_relevel 値の順序を指定し、データタイプをfactor型に変換します。
fct_reorder 別の列のソートした値に基づいて値の順序を設定し、データタイプをfactor型に変換します。
fct_rev factor型の列のレベルを反転させます。
impute_na impute_naでは、平均値や中央値や最頻値、手動で指定した値、または線形回帰モデルによる予測値によって欠損値を埋めることができます。予測値を使って埋める場合は、予測変数の列を指定する必要があり、予測変数の列は複数指定が可能です。
get_mode 最も頻度の多い値を返します。
summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。
summarize_row 指定した集計関数を利用して、各行の列の値を集計 します。
mutate_group 表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。
exp_cut_by_step 数値データを等間隔（例：500刻み）でグループに分けて、該当するグループ名を返します。format_cut_output関数と組み合わせることで、区間の表示形式をカスタマイズできます。
exp_cut 数値データを等幅でグループに分けて、該当するグループ名を返します。format_cut_output関数と組み合わせることで、区間の表示形式をカスタマイズできます。

Range

range 指定されたデータの最小値と最大値を返します。
between 注目している値が、指定された範囲内にあるかどうかをもとに、 TRUE または FALSE を返します。

Statistics

cor 2つの列の値の相関関係を計算します。共分散を2 つの列の値の標準偏差の積で割ることで計算されます。
cov 2つの列の値の共分散を計算します。

List

str_detect 特定の文字列が含まれているかどうかに基づいて、TRUEまたはFALSEを返します。
list_extract リスト内のデータがデータフレームの場合、位置または名前をもとにリストのデータ型の列の値を抽出します。
list_to_text リストデータ型の列のすべての要素のテキストを連結します。
list_concat 複数の列の値をリストとして連結します。
list_n 行ごとにリストデータ型の列内の要素の数を返します。

Cleaning

fill 欠損値（NA）を前の行または後の行の値で埋めます。特に、データが省略されている場合に、同じグループ内で値を補完するのに便利です。

tidyr sub-function

full_seq 指定した列の値に基づいて数値シーケンスを生成します。

URL

param_remove 指定したURLからパラメータを削除します。
url_decode 指定したURLをデコードします。 文字コードはUTF-8を前提としています。
url_encode 指定したURLをエンコードします。 文字コードはUTF-8を前提としています。
url_parameters url からデコードされたクエリのパラメーターを返します。
url_domain url からドメイン (例: "exploratory.io")を返します。
url_fragment url からフラグメントを返します。
url_path urlからパスを返します。
url_port url からポートを返します。
url_scheme urlからスキーム（例："http"、"https"）を返します。
url_suffix urlから接尾辞（例："com"、"org"）を返します。
url_subdomain urlからサブドメイン (例 "www", "blog") を返します。
url_tld url からトップレベルドメイン (例 "com"、"co") を返します。
url_param url からデコードされたクエリパラメーターを返します。

Column

- Removes column(s). It can be used along with any column(s) selection operation like select(), gather(), etc.

Column Selection

starts_with 指定したテキストで始まる列名の列を返します。select()、mutate_at()、summarize_at()などの関数と組み合わせて使用します。
ends_with 指定したテキストで終わる列名の列を返します。select()、mutate_at()、summarize_at()などの関数と組み合わせて使用します。
contains 指定したテキストを含む列名の列を返します。select()、mutate_at()、summarize_at()などの関数と組み合わせて使用します。
matches 正規表現のパターンに一致する列名の列を返します。
num_range 指定したテキストに続く数値が指定した範囲内にある列名の列を返します。X1、X2、X3、X4などの連番の列名がある場合に特に便利です。
any_of 指定した名前のいずれかに一致する列名の列を返します。存在しない列名を指定しても、エラーにはなりません。
everything すべての列名を返します。特定の列を最初に配置し、その後にすべての列を配置したい場合に特に便利です。
where 指定した列選択関数（例：is.numeric関数）の戻り値がTRUEとなる列を返します。
across summarize_rowなど、他の関数で使用する列を選択するときに利用する関数です。

dplyr-subfunction

vars ユーザーが選択した列のリストを返します。主にsummarize_at()、mutate_at()、filter_at()などの関数で、特定の列を選択するために使用されます。

POSIXct

as_date POSIXct型の列をDate型に変換できます。
weekend 指定した日付列の値をもとに、平日か週末かのラベルをつけます。
is_japanese_holiday is_jholiday関数のエイリアスです。指定した日付が日本の祝日の場合、TRUEを返します。
is_jholiday 指定された日付が日本の祝日だった場合にTRUEを返します。

Data Wrangling

remove_empty 空の行や列を削除します。データフレームから空（NA、NULL、空白）の行や列を取り除くのに便利です。

Model Function

xgboost_reg Create extreme gradient boosting model for regression.
xgboost_binary Create extreme gradient boosting model for binary classification.
xgboost_multi Create extreme gradient boosting model for binary classification.
randomForestReg Create random forest model for regression.
randomForestBinary Create random forest model for binary classification.
randomForestMulti Create random forest model for multi class classification.

Survival Analysis

do_survfit 生存時間データから生存曲線を計算します。なお日付列のみでは生存曲線は計算できないため、開始日を表す列と終了日を表す列などから、あらかじめ`weeks_between()`、`months_between()`、`years_between()`関数などを使って、期間の情報を計算しておく必要があります。
prediction_survfit 生存モデルに基づいて、指定されたコホートの生存曲線をシミュレーションします。
build_coxph 生存分析のためのCox比例ハザードモデルを作成し、データフレームに格納します。
prediction_coxph Cox比例ハザードモデルの予測値を含むデータフレームを返します。

Geo

ip_to_country IPアドレスから国名を返します。

Geographic

countrycode 国名や国名コードを他の形式の国コードや名前（国名、大陸名、地域名など）に変換します。国際的なデータ分析やレポート作成時に、異なるデータソースの国コードを統一するのに役立ちます。
prefecturecode 都道府県名を対応する都道府県コード（JIS X 0401で定義された2桁の数値コード）に変換します。例えば「東京都」は「13」、「大阪府」は「27」に変換されます。
is_prefecture 文字列が正しい都道府県名かどうかを判定します。市区町村名などの余分な文字列が含まれている場合や、正しくない都道府県名の場合はFALSEを返します。

Text Analysis

do_tokenize テキストをトークン化（単語や文などに分割）して、1行につき1つのトークンを返します。
pair_count グループ内で共起する単語のペア（単語の組み合わせ）を数えます。
do_tfidf 各グループに対する各単語のTF-IDF（Term Frequency-Inverse Document Frequency）を計算します。TF-IDFは、単語の出現頻度に基づいて重要度を上げる一方、文書頻度に基づいて重要度を下げることにより、各文書内の各単語の重要性を計算する重み付け手法です。
do_ngram 文章内のトークンを連結してn-gramの列を作成します。
do_cosine_sim.kv コサイン類似度アルゴリズムを使用して、各ドキュメント間の類似度を計算します。コサイン類似度は多次元空間における2つのベクトル間の角度のコサインを測定します。テキストマイニングにおいては、文書間の類似性を数値化するのに役立ちます。

Encoding

one_hot カテゴリカルデータの列をワンホットエンコーディングし、それぞれのカテゴリに対応する新しい列を作成します。新しい列は、行がそのカテゴリに該当する場合は1、それ以外は0を持ちます。

Summarize

summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。

Group By

summarize_group 指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。
mutate_group 表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。

Sampling

exp_balance SMOTE（Synthetic Minority Oversampling Technique）を使用して、不均衡なデータをバランスの取れたデータに変換します。少数派の合成データを作成し、多数派クラスのデータを適切に調整することで、バイアスのない機械学習モデルを構築しやすくします。対象となる列は0/1 の数値、または 2 値のカテゴリデータ、ロジカル型の列に限定されます。

Machine Learning

exp_balance SMOTE（Synthetic Minority Oversampling Technique）を使用して、不均衡なデータをバランスの取れたデータに変換します。少数派の合成データを作成し、多数派クラスのデータを適切に調整することで、バイアスのない機械学習モデルを構築しやすくします。対象となる列は0/1 の数値、または 2 値のカテゴリデータ、ロジカル型の列に限定されます。

Numeric

exp_cut_by_step 数値データを等間隔（例：500刻み）でグループに分けて、該当するグループ名を返します。format_cut_output関数と組み合わせることで、区間の表示形式をカスタマイズできます。
exp_cut 数値データを等幅でグループに分けて、該当するグループ名を返します。format_cut_output関数と組み合わせることで、区間の表示形式をカスタマイズできます。
kansuji2arabic_num 漢数字（一、二、三など）をアラビア数字の文字列（1、2、3など）に変換します。この関数は数値ではなく文字列を返すため、数値として扱いたい場合は`as.numeric`関数と組み合わせる必要があります。

!

概要
次の条件の意味を反転します。これは論理否定であり、「Not」と同様の意味を持ちます。

シンタックス
!<条件>

返り値

例
filter(!is.na(X1)) X1列の欠損値でない行を保持します。

X1 NEW
1
NA (行が除外されます)
3

filter(!str_detect(X1, "Francisco")) X1列に「Francisco」の文字列が含まれていない行を保持します。

X1 NEW
"San Francisco" (行が除外されます)
"New York"
"South Francisco" (行が除外されます)

filter(!X1 > 500) X1列の値が500を超えない行を保持します。

X1 NEW
600 (行が除外されます)
400
500

abbreviate

概要
文字列をminlength文字に短縮し、一意にできるようにします。まず、文字列の先頭にある全てのスペースが削除されます。 その後、必要に応じて他のスペースが削除されます。次に、小文字の母音が (右から順に) 削除され、続いて小文字の子音が削除されます。最後に、省略形がminlengthよりも長い場合は、大文字が削除されます。

シンタックス
abbreviate(<列名>, minlength = <数値>, dot = <TRUE|FALSE>)

引数

返り値
Character

例
abbreviate(X1) X1列の文字列を省略形に変換します。デフォルトでは4文字になります。

X1 NEW
Exploratory Expl
Statistics Stat
Development Devl

abbreviate(X1, 3) X1列の文字列を、指定された長さ（この場合は3文字）に省略します。

X1 NEW
Exploratory Exp
Statistics Sta
Development Dev

abs

概要

数値を絶対値として返す。

シンタックス
abs(<数値列>)

返り値
Numeric

例
abs(ARR-DELAY) 数値を絶対値として返します。

ARR-DELAY NEW
1 1
-3 3
-10 10

acos

概要
逆余弦の値をラジアン単位で返します。

シンタックス
acos(<数値列>)

返り値
Numeric

例 acos(X1) X1列に対してacosで計算した値を返します。

X1 NEW
1 0
0 1.570796327
-1 3.141592654

acosh

概要
逆双曲線余弦の数値を返します。

シンタックス
acosh(<数値列>)

返り値
Numeric

例
acosh(NUMBER) X1列に対してacoshで計算した値を返します。

X1 NEW
1 0
0 1.570796327
-1 3.141592654

all

概要
行またはグループ内の行ですべての行が指定した条件を満たす場合、TRUEを返します。

シンタックス
all(<条件>, na.rm = <TRUEまたはFALSE>)

引数

返り値
Logical

例 all(X1 >= 500) X1列の全ての値が500以上の場合はTRUEを返し、500よりも小さい値を一つでもある場合はFALSEを返します。主に集計の際に使用されますが、計算を作成でも使用することができます。

X1 NEW
400 FALSE
600 FALSE
700 FALSE

any

概要
行またはグループ内の行で指定した条件を満たすものが一つでもある場合、TRUEを返します。

シンタックス
any(<条件>, na.rm = <TRUEまたはFALSE>)

引数

返り値
Logical

例
any(X1 >= 500) X1列に500以上の値が1つでも存在する場合はTRUEを返し、500よりも小さい値を一つも含まない場合はFALSEを返します。主に集計の際に使用されますが、計算を作成でも使用することができます。

X1 NEW
400 TRUE
600 TRUE
700 TRUE

as.character

概要
データタイプを文字列型（Character）に変換します。

シンタックス
as.character(<列名>)

返り値
Character

例
as.character(123.11)
文字列型として"123.11"を返します。

as.Date

概要

データタイプを日付型（Date）に変換します。日付型のデータには時間の情報は含まれません。デフォルトのフォーマットは「2020-01-01」と表現するISO8601の国際規格に従います。

シンタックス
as.Date(<列名>, format = <日付のフォーマット>, tz = <タイムゾーン>, origin = <日付のテキスト>)

引数

返り値
Date

例
as.Date("2015-10-10")
"2015-10-10"を日付型で返します。
as.Date("10-10-10", format = "%d-%m-%y")
"2010-10-10"を日付型で返します。
as.Date(35981, origin = "1899-12-30") # WindowsのExcelのデータで推薦されます。 "1998-07-05"を日付型で返します。
as.Date(34519, origin = "1904-01-01") # MacのExcelのデータで推薦されます。 "1998-07-05"を日付型で返します。

as.double

概要
データタイプを不動小数点型（double）に変換します。数値型（Numeric）と同じ挙動になります。

シンタックス
as.double(<列名>)

返り値
Double

例
as.double("12345")
12345を返します。
as.double("12345.10")
12345.1を返します。

as.factor

概要
指定した列をFactor型に変換します。

シンタックス
as.factor(<列名>)

引数

返り値
Factor

例
columnA - "iMac", "iPod", "iPhone", "iPod", "iPhone"
as.factor(columnA)
データとしてはiMac, iPod, iPhone, iPod, iPhoneを返しますが、レベルとしてはiMac, iPhone, iPodを返します。

as.integer

概要
データタイプを整数型（integer）に変換します。

シンタックス
as.integer(<列名>)

返り値
Integer

例
as.integer("12345")
12345を返します。
as.integer("12345.10")
12345を返します。

as.logical

概要
変換対象の列をロジカル型（TRUE/FALSE）に変換します。数値の場合は0がFALSE、0以外の値がTRUEに変換されます。 文字列の場合は"TRUE"、"True"、"true"、"T"、"t"がTRUEに、"FALSE"、"False"、"false"、"F"、"f"がFALSEに変換されます。それ以外の文字列はNAになります。

シンタックス
as.logical(<変換対象の列)

引数

返り値
Logical

例

as.logical(数値の列)

数値の列をロジカル型に変換します。0はFALSE、0以外の数値はTRUEに変換されます。

数値の列 変換後
0 FALSE
1 TRUE
1 TRUE
0 FALSE

as.logical(文字列の列)

文字列の列をロジカル型に変換します。"TRUE"/"FALSE"およびその変形のみが変換され、それ以外はNAになります。

文字列の列 変換後
TRUE TRUE
False FALSE
t TRUE
Yes NA
No NA

as.numeric

概要
データタイプを数値型（Numeric）に変換します。

シンタックス
as.numeric(<列名>, units = <単位>)

引数

返り値
Numeric

例
as.numeric("12345")
「12345」を数値型として返します。
as.numeric(as.Date("2015-01-30") - as.Date("2015-01-15"), units = "days")
difftime型のデータから日数である「15」を返します。
as.numeric(as.Date("2015-01-30") - as.Date("2015-01-15"), units = "weeks")
difftime型のデータから週数である「2.142857」を返します。

as.POSIXct

概要
データタイプを日付・時間型（POSIXct）に変換します。

シンタックス
as.POSIXct(<列名>, format = <日付時間のフォーマット>, tz = <タイムゾーン>, origin = <日付のテキスト>)

引数

返り値
POSIXct

例
as.POSIXct("2015-10-10 13:10:05") "2015-10-10 13:10:05 PDT"を返します。
as.POSIXct("2015-10-10 13:10:05", tz = "America/Los_Angeles") "2015-10-10 13:10:05 PDT"を返します
as.POSIXct("2015-10-10 13:10:05", tz = "Asia/Tokyo") "2015-10-10 13:10:05 JST"を返します。
as.POSIXct("05-10-15T13:10:05", format = "%d-%m-%yT%H:%M") "2015-10-05 13:10:00 PDT"を返します。

asin

概要
逆正弦の値をラジアン単位で返します。

シンタックス
asin(<数値列>)

返り値
Numeric

例
asin(X1) X1列に対してasinで計算した値を返します。

X1 NEW
-0.2 -0.2013579208
0.9 1.119769515
0.3 0.304692654

asinh

概要
逆双曲線正弦の数値を返します。

シンタックス
asinh(<数値列>)

返り値
Numeric

例
asin(X1) X1列に対してasinhで計算した値を返します。

X1 NEW
-0.2 -0.1986901103
0.9 0.8088669357
0.3 0.2956730476

atan

概要
逆正接の値をラジアン単位で返します。

シンタックス
atan(<数値列>)

返り値
Numeric

例
atan(X1) X1列に対してatanで計算した値を返します。

X1 NEW
-0.2 -0.1973955598
0.9 0.7328151018
0.3 0.2914567945

atan2

概要
x軸と原点（0,0）から指定された座標ペア (x,y) までの線分との間の角度をラジアン単位で返します。

シンタックス
atan2(<X1>, <Y1>)

返り値
Numeric

例
atan2(X1, Y2) atan2で計算した値を返します。

X1 Y1 NEW
2 1 1.107148718
11 5 1.144168834
5 7 0.620249486

atanh

概要
逆双曲線正接の数値を返します。

シンタックス
atanh(<数値列>)

返り値
Numeric

例
atanh(X1) atanhで計算した値を返します。

X1 NEW
-0.2 -0.2027325541
0.9 1.47221949
0.3 0.3095196042

c

概要
いくつかの引数を組み合わせるための一般的な関数です。

シンタックス
c(<value1>, <value2>, ... , recursive = <TRUE|FALSE>)

引数

例
c("High", "Low", "Medium")) 指定したカテゴリーのベクトルを追加します。

X1 NEW
Task1 High
Task2 Low
Task3 Medium

ceiling

概要

数値を整数または指定した小数点で切り上げる。

シンタックス
ceiling(<数値列>, digits = <桁数>)

引数

返り値
Numeric

例
ceiling(X1, digits=2) 小数点第二位で切り上げた値を返します。

X1 NEW
-0.2344 -0.23
0.91098 0.92
0.311785 0.32

chartr

概要
oldで指定された各文字を、newで指定された対応する文字に変換します。

シンタックス
chartr(<old_text>, <new_text>, <column_text>)

引数

返り値
Character

例
x = "abcdef 123456" chartr("abc", "xyz", x)
"xyzdef 123456"を返します。
chartr("a-f", "u-z", x)
"uvwxyz 123456"を返します。
chartr("a-f", "xxxxxx", x)
"xxxxxx 123456"を返します。
chartr("123", "000", x)
"abcdef 000456"を返します。

cos

概要
指定された角度のコサインをラジアン単位で返します。

シンタックス
cos(<数値列>)

返り値
Numeric

例
cos(X1) X1列に対してcosで計算した値を返します。

X1 NEW
2 -0.4161468365
0.9 0.6216099683
3 -0.9899924966

cosh

概要
任意の実数の双曲線余弦を返します。

シンタックス
cosh(<数値列>)

返り値
Numeric

例
cosh(X1) X1列に対してcoshで計算した値を返します。

X1 NEW
2 3.762195691
-0.9 1.433086385
3 10.067662

cospi

概要
cos(pi * )を返します。

シンタックス
cospi(<数値列>)

返り値
Numeric

例
cospi(X1) X1列に対してcospiで計算した値を返します。

X1 NEW
2 1
-0.9 -0.9510565163
3 -1

cummax

概要
累積最大値を返します。

シンタックス
cummax(<数値列>)

返り値
Numeric

例
cummax(X1) X1列の値について、各行までの最大値を順番に返します。

X1 NEW
3 3
5 5
2 5

cummin

概要
累積最小値を返します。

シンタックス
cummin(<数値列>)

返り値
Numeric

例
cummin(X1) X1列の値について、各行までの最小値を返します。

X1 NEW
3 3
5 3
2 2

cumprod

概要
累積積を返します。

シンタックス
cumprod(<数値列>)

返り値
Numeric

例 cumprod(X1) X1列の値について、各行までの積を順番に返します。

X1 NEW
1 1
2 2
3 6

cumsum

概要
累積合計値を返します。

シンタックス
cumsum(<数値列>)

返り値
Numeric

例 cumsum(X1) X1列の値について、各行までの合計を順番に返します。

X1 NEW
1 1
2 3
3 6

cut

概要
数値を指定した数に分割し、その間隔の値（下限,上限）を返します。

シンタックス
cut(<数値列>, breaks = <数値>, labels = <文字列>, include.lowest = <TRUE|FALSE>, right = <TRUE|FALSE>, dig.lab = <数値>), ordered_result = <TRUE|FALSE>)

引数

例

format_cut_output(cut(売上, breaks = c(-Inf, 1000, 5000, 10000, Inf), right = FALSE, dig.lab = 20), right = FALSE, decimal.digits = 2) 売上の列の値を1000、5000、10000で区切ってグループに分け、どのグループに属するかの値を返します。

売上 売上_カテゴリー
221.98 < 1,000.00
3709.395 1,000.00 - 5,000.00
5175.171 5,000.00 - 10,000.00
341.96 < 1,000.00

cut(X1, breaks = 5) X1列に対して以下の値を返します。

X1 NEW
1 (0.991,2.8]
2 (0.991,2.8]
3 (2.8,4.6]
4 (2.8,4.6]
5 (4.6,6.4]
6 (4.6,6.4]
7 (6.4,8.2]
8 (6.4,8.2]
9 (8.2,10]
10 (8.2,10]

cut(X1, breaks = 2) X1列に対して以下の値を返します。

X1 NEW
1 (0.991,5.5]
2 (0.991,5.5]
3 (0.991,5.5]
4 (0.991,5.5]
5 (0.991,5.5]
6 (5.5,10]
7 (5.5,10]
8 (5.5,10]
9 (5.5,10]
10 (5.5,10]

cut(X1, breaks = 2, labels = c(1,2)) X1列に対して以下の値を返します。

X1 NEW
1 1
2 1
3 1
4 1
5 1
6 2
7 2
8 2
9 2
10 2

cut(X1, breaks = 2, labels = c("A", "B")) X1列に対して以下の値を返します。

X1 NEW
1 A
2 A
3 A
4 A
5 A
6 B
7 B
8 B
9 B
10 B

difftime

概要
指定された2つの日付・時間の差を計算します。

シンタックス
difftime(<日付・時間列>, <日付・時間列>, tz = <タイムゾーン>, units = <期間の単位>)

引数

返り値
Difftime

例
difftime(X1, X2) X1列とX2列の日付の期間を日単位で計算します。

X1 X2 NEW
2023-01-10 2023-01-20 -10

difftime(X1, X2, units="hours") X1列とX2列の日付の期間を時間単位で計算します。

X1 X2 NEW
2023-01-10 2023-01-20 -240

as.numeric(difftime(X1, X2)) X1列とX2列の日付の期間を最も適切な単位で数値型の値として返します。

X1 X2 NEW
2023-01-10 2023-01-20 -10

as.numeric(difftime(X1, X2, units="hours")) X1列とX2列の日付の期間を数値型の時間数で返します。

X1 X2 NEW
2023-01-10 2023-01-20 -240

duplicated

概要
重複した値または行であるかどうかを（TRUE、FALSE）で返します論理値。

シンタックス
duplicated(<列名>, incomparables = <TRUE|FALSE>)

引数

返り値
Logical

例 duplicated(X1) X1列の値が重複しているかどうかを論理値（TRUE、FALSE）で返します。

X1 NEW
"a" FALSE
"b" FALSE
"a" TRUE

duplicated(X1, incomparables = "a") X1列の各値が重複しているかを、"a"を重複判定から除外したうえで、論理値（TRUE、FALSE）で返します。

X1 NEW
"a" FALSE
"b" FALSE
"a" FALSE

filter(duplicated(X1, X2)) X1列とX2列の組み合わせが重複している行のみにフィルタします。

X1 X2 NEW
10:00 5 (行が除外されます)
9:00 10 (行が除外されます)
10:00 5

exp

概要
ネイピア数（オイラー数）のe（~2.718）の累乗を返します。

シンタックス
exp(<数値列>)

返り値
Numeric

例
exp(X1) X1を指数化した値を返します。

X1 NEW
1 2.718281828
-3 0.04978706837
10 22026.46579

factor

概要
レベル（順序）を指定して、列をFactor型に変換します。

シンタックス
factor(<列名>, levels = <値>, labels = <文字列>, exclude = <文字列>, ordered = <TRUE|FALSE>, nmax = <数値>)

引数

返り値
Factor

例

factor(color, levels = c("Gold","Silver","Bronze"), ordered=TRUE)

Before:

color counts
Bronze 8
Silver 12
Gold 15

After:

color counts
Gold 15
Silver 12
Bronze 8

floor

概要

数値を整数または指定した小数点で切り捨てる。

シンタックス

floor(<数値列>, digits = <桁数>)

引数

返り値
Numeric

例
floor(X1, digits=2) X1を小数点第ニ位で切り捨てます。

X1 NEW
-0.2344 -0.24
0.91098 0.91
0.311785 0.31

iconv

概要
指定されたテキストをあるエンコーディングから別のエンコーディングに変換します。

シンタックス
iconv(<列名>, from = <変換前のエンコーディング>, to = <変換後のエンコーディング>, sub = <文字列>, mark = <TRUE|FALSE>, toRaw = <TRUE|FALSE>)

引数

返り値
Character

例
iconv(X1, from="SHIFT-JIS", to="UTF-8") X1列の文字コードをShift-JISからUTF-8に変換して返します。

X1 NEW
���{�� 日本語
���������� あいうえお
�莆 手紙

ifelse

概要
条件の結果に基づいて、異なる値を返します。

シンタックス
ifelse(<条件>, <条件にマッチした時に返す値>, <条件にマッチしない時に返す値>)

引数

返り値

例
ifelse(X1 > 3, "Bigger", "Smaller") X1列の値が3より大きい場合は"Bigger"を、そうでない場合は"Smaller"を返します。

X1 NEW
1 Smaller
4 Bigger
2 Smaller

intersect

概要
複数のデータフレームに共通して存在する行のみを抽出します。集合演算の「積集合」に相当します。

シンタックス
intersect(<データフレーム1>, <データフレーム2>, ...)

引数 データフレーム - 共通の行を探したいデータフレームを指定します。複数のデータフレームを指定できます。

例

元のデータ1:

ID 商品名 価格
1 りんご 100
2 みかん 80
3 バナナ 120

元のデータ2:

ID 商品名 価格
2 みかん 80
3 バナナ 120
4 キウイ 150

intersect(元のデータ1, 元のデータ2) データ1とデータ2の両方に存在する行のみを抽出します。

ID 商品名 価格
2 みかん 80
3 バナナ 120

is.character

概要
指定されたオブジェクトがCharacter（文字列）型の場合はTRUEを返します。

シンタックス
is.character

返り値
Logical

例
mutate_if(is.character(X1), str_to_lower) X1列が文字列型の場合、全ての文字を小文字に変換します。

X1 NEW
Hello hello
WORLD world
R Studio r studio

is.double

概要
指定されたオブジェクトがDouble（不動小数点）型の場合はTRUEを返します。

シンタックス
is.double

返り値
Logical

例
is.double(X1) X1列がDouble型の場合、TRUEを返します

X1 NEW
1.2 TRUE
3.7 TRUE
2.5 TRUE

is.factor

概要
指定されたオブジェクトがFactor（順序付きカテゴリー型）の場合はTRUEを返します。

シンタックス
is.factor

返り値
Logical

例
is.factor(X1) X1列がファクター型の場合、TRUEを返します。

X1 NEW
A TRUE
B TRUE
C TRUE

is.list

概要
指定されたオブジェクトがList型の場合はTRUEを返します。

シンタックス
is.list

返り値
Logical

例

select_if(is.list)
リスト型の列のみを選択します。

is.logical

概要
指定されたオブジェクトがLotical（論理値）型の場合はTRUEを返します。

シンタックス
is.logical

返り値
Logical

例
mutate_if(is.logical, as.numeric) ロジカル型の列の値を数値に変換します。主に集計の際に使用されますが、計算を作成でも使用することができます。

X1 NEW
TRUE 1
FALSE 0
TRUE 1

summarize_if(is.logical, sum) すべてのLogical型の列のTRUEの合計値を集計します。

is.matrix

概要
指定されたオブジェクトがMatrix型の場合はTRUEを返します。

シンタックス
is.matrix

返り値
Logical

例

mutate_if(is.matrix, scale)
すべてのMartix型の列の行列をスケールして中央に配置します。

is.na

概要
欠損値の場合にTRUEを返します。

シンタックス
is.na(<列名>)

返り値
Logical

例
is.na(X1) X1列の値が欠損値(NA)かどうかを論理値（TRUE、FALSE）で返します。

X1 NEW
1 FALSE
NA TRUE
3 FALSE

is.null

概要
nullの場合にTRUEを返します。

シンタックス
is.null(<列名>)

返り値
Logical

例 is.null(X1) X1列の値がNULLかどうかを論理値（TRUE、FALSE）で返します。

X1 NEW
TRUE
1 FALSE
a FALSE

is.numeric

概要
指定されたオブジェクトがNumeric（数値）型の場合はTRUEを返します。

シンタックス
is.numeric

返り値
Logical

例
mutate_if(is.numeric, funs(. * 0.2)) 数値型の列に0.2を乗算して、既存の列を上書きします。なお、集計の際にも使用することが可能です。

X1 NEW
10.5 2.1
4 0.8
42 8.4

summarize_if(is.numeric, mean) すべてのNumeric型の列の平均値を計算します。

isTRUE

概要
指定された値がTRUEである場合にのみTRUEを返します。

シンタックス
isTRUE()

返り値
Logical

例
isTRUE(TRUE) X1列がTRUEであるかを判定します。なお、集計の際にも使用することが可能です。

X1 NEW
TRUE TRUE
FALSE FALSE
NA FALSE

summarise(a = isTRUE(mean(ARR-DELAY) > 120))
各グループのARR-DELAYの平均値に基づいてTRUEまたはFALSEを返します。

length

概要
値の長さを返します。

シンタックス
length(<列名>)

返り値
Numeric

例
summarize(text_length = length(TAIL_NUM))
各グループの値の数を返します。

levels

概要
指定されたFactor型のレベルを返します。

シンタックス
levels(<列名>)

例
// x <- as.factor(c("a", "b", "c", "d", "e", "a", "b", "a"))
levels(x)
"a" "b" "c" "d" "e"を返します。
summarise(n = length(levels(as.factor(flight$CARRIER))))
16を返します。

list

概要
リストを作成します。

シンタックス
list(<列>)

返り値
List

例
list(sales = 0, profit = 10)
[sales = 0, profit = 10]の名前つきのリストを作成します。

log

概要
対数を返します。デフォルトは自然対数での値を返します。

シンタックス
log(<数値列>, base = <数値>)

引数

返り値
Numeric

例
log(X1) X1に対する自然対数の値を返します。

X1 NEW
10000 9.210340372
2500000 14.73180129
3.00E+07 17.21670794

log10

概要
常用対数（10を底とする対数）を返します。

シンタックス
log10(<数値列>, base = <数値>)

引数

返り値
Numeric

例
元データ

X1
10000
2500000
30000000

log10(X1) X1に対する常用対数（10を底とする対数）を返します。

X1 X1_ log10
10000 4
2500000 6.397940009
30000000 7.477121255

log1p

概要
log(1+数値) の値を返します。数値がゼロに近い場合でも、正確な値が計算できます。

シンタックス
log1p(<数値列>, base = <数値>)

引数

返り値
Numeric

例
log1p(X1) X1に1を足した値の自然対数を返します。

X1 NEW
0.2 0.1823215568
0.9 0.6418538862
0.3 0.2623642645

log2

概要
二進対数（2を底とする対数）を返します。

シンタックス
log2(<数値列>, base = <数値>)

引数

例
Numeric

例
log2(X1) X1に対する二進対数（2を底とする対数）を返します。

X1 NEW
10000 13.28771238
2500000 21.25349666
30000000 24.83845916

max

概要
すべての値の最大値を返します。

シンタックス
max(<数値またはロジカル型の列>, na.rm = <TRUEまたはFALSE>)

引数

例
max(売上) 売上の最大値を返します。主に集計の際に使用されますが、計算を作成でも使用することができます。

mean

概要
すべての値の平均値を返します。

シンタックス
mean(<数値またはロジカル型の列>, na.rm = <TRUEまたはFALSE>, trim = <数値>)

引数

返り値
Numeric

例
mean(売上) 売上の平均値を返します。主に集計の際に使用されますが、計算を作成でも使用することができます。

min

概要
すべての値の最小値を返します。

シンタックス
min(<数値またはロジカル型の列>, na.rm = <TRUEまたはFALSE>)

引数

例
min(売上) 売上の最小値を集計した結果を返します。主に集計の際に使用されますが、計算を作成でも使用することができます。

months

概要

計算に使用できるように、数値を月の単位に変換します。

シンタックス
months(<数値列>)

返り値
Period

例
X1 + months(1) X1列の1ヶ月後の日付を返します。

X1 NEW
2015-10-01 6:15:30 2015-11-01 6:15:30
2014-03-03 14:15:30 2014-04-03 14:15:30
2017-12-01 23:15:30 2018-01-01 23:15:30

nchar

概要
指定された値の文字数またはサイズを返します。

シンタックス
nchar(<列名>, type = "chars"|"bytes"|"width", allowNA = <TRUE|FALSE>)

引数

返り値
Numeric

例
nchar(X1) X1列の文字列について、文字数を返します。

X1 NEW
Exploratory 11
Data 4
Hello123 8

nchar(X1, type = "bytes") X1列の文字列について、バイト数を返します。アルファベットと数字は1文字1バイトとしてカウントされます。

X1 NEW
ABC 3
Data123 7
Excel2024 9

pmax

概要
並列する値のうち、どちらかの最大値を返します。

シンタックス
pmax(<列名>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
pmax(X1,X2) X1またはX2のうち、大きい方の値を返します。

X1 X2 NEW
2 1 2
11 5 11
5 7 7

pmin

概要
並列する値のうち、どちらかの最小値を返します。

シンタックス
pmin(<列名>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
pmax(X1,X2) X1またはX2のうち、小さい方の値を返します。

X1 X2 NEW
2 1 1
11 5 5
5 7 5

prod

概要
指定されたデータの一連の数値を乗算して積値を返します。

シンタックス
prod(<列名>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
// x <- 1:5
prod(x)
120を返します。

range

概要
指定されたデータの最小値と最大値を返します。

シンタックス
range(<列名>, na.rm = <TRUE|FALSE>)

引数

返り値

例
// x <- c(1, 2, 3, 4, 5)
1と5を返します。
filter(ARR-DELAY %in% range(DEP-DELAY, na.rm = TRUE))
ARR-DELAYがDEP-DELAYの範囲内にある行のみを保持します。

rep

概要
指定された値を繰り返し複製します。

シンタックス
rep(<列名>, times = <数値>, length.out = <数値>, each = <数値>)

引数

返り値
Numeric

例
x <- c(1, 2, 3, 4, 5) rep(x, 2)

数値ベクトルxを2回繰り返します。結果は「1 2 3 4 5 1 2 3 4 5」となります。

x <- c(1, 2, 3, 4, 5) rep(x, times = 2)

数値ベクトルxを2回繰り返します。timesパラメータを明示的に指定した例です。結果は「1 2 3 4 5 1 2 3 4 5」となります。

x <- c(1, 2, 3, 4, 5) rep(x, length.out = 8)

数値ベクトルxを繰り返して、長さが8になるようにします。結果は「1 2 3 4 5 1 2 3」となります。

x <- c(1, 2, 3, 4, 5) rep(x, times = 2, each = 2)

数値ベクトルxの各要素を2回ずつ繰り返し、さらにその結果を2回繰り返します。結果は「1 1 2 2 3 3 4 4 5 5 1 1 2 2 3 3 4 4 5 5」となります。

x <- c(1, 2, 3, 4, 5) rep(x, length.out = 8, each = 2)

数値ベクトルxの各要素を2回ずつ繰り返し、合計長さが8になるように調整します。結果は「1 1 2 2 3 3 4 4」となります。

rev

概要
指定されたデータの要素の順序を逆転します。

シンタックス
rev(<列名>)

引数

返り値
元のデータと同じデータ型で、順序が逆転された値を返します。

例
x <- c(1, 2, 3, 4, 5) rev(x)

数値ベクトルxの要素の順序を逆転します。結果は「5 4 3 2 1」となります。

months <- c("1月", "2月", "3月", "4月") rev(months)

文字列ベクトルの順序を逆転します。結果は「4月 3月 2月 1月」となります。

df <- data.frame(x = 1:3, y = 4:6) rev(df$x)

データフレームの列xの要素の順序を逆転します。結果は「3 2 1」となります。

round

概要

数値を整数または指定した小数点で四捨五入する。

シンタックス
round(<数値列>, digits = <桁数>)

引数

返り値
Numeric

例
round(X1, digits=2) 小数点第二位で四捨五入した値を返します。

X1 X2 pmin
2 1 1
11 5 5
5 7 5

seq

概要
Returns a sequence of numbers.

シンタックス
seq(from = <数値>, to = <数値>, by = <数値>, length.out = <数値>, along.with = <列名>)

引数

返り値
Numeric

例
seq(1, 5)
Returns 1 2 3 4 5 seq(1, 5, by = 2)
Returns 1 3 5
seq(1:5)
Returns 1 2 3 4 5
seq(0, 1, length.out = 11)
Returns 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
seq(ymd("2017-04-01"), by = "month", length.out = 6) Returns "2017-04-01" "2017-05-01" "2017-06-01" "2017-07-01" "2017-08-01" "2017-09-01" - It will generate date values for the next 6 months.

setdiff

概要
最初のデータフレームにあり、2番目以降のデータフレームにない行のみを抽出します。集合演算の「差集合」に相当します。

シンタックス
setdiff(<データフレーム1>, <データフレーム2>, ...)

例

データ1:

ID 商品名 価格
1 りんご 100
2 みかん 80
3 バナナ 120

データ2:

ID 商品名 価格
2 みかん 80
3 バナナ 120
4 キウイ 150

setdiff(データ1, データ2) データ1にあり、データ2にない行のみを抽出します。

ID 商品名 価格
1 りんご 100

sign

概要
値が正、0、または負であるかどうかに応じて、それぞれ1、0、-1を返します。

シンタックス
sign(<数値列>)

返り値
Numeric

例
sign(X1) 値が正、0、または負であるかどうかに応じて、それぞれ1、0、-1を返します。

X1 NEW
1 1
2 1
10 1
0 0
-1 -1
-2 -1
-10 -1

signif

概要
値を指定した有効桁数に四捨五入します。

シンタックス
signif(<数値列>, digits = <数値>)

引数

返り値
Numeric

例
signif(X1, digits=2) X1の数値を四捨五入して、有効数字が2桁にします。

X1 NEW
3.475 3.48
123.456 123
0.00456 0.00456

sin

概要
指定された角度のサインをラジアン単位で返します。

シンタックス
sin(<数値列>)

返り値
Numeric

例
sin(X1) X1列に対してsinで計算した値を返します。

X1 NEW
1 0.8414709848
-3 -0.1411200081
10 -0.5440211109

sinh

概要
任意の実数の双曲線正弦を返します。

シンタックス
sinh(<数値列>)

返り値
Numeric

例
sin(X1) X1列に対してsinhで計算した値を返します。

X1 NEW
1 1.175201194
-3 -10.01787493
10 11013.23287

sinpi

概要
sin(pi * )を返します。

シンタックス
sinpi(<数値列>)

返り値
Numeric

例
sinpi(X1) X1列に対してsinpiで計算した値を返します。

X1 NEW
1 0
0.5 1
-0.5 -1

sqrt

概要
値の平方根を返します。

シンタックス
sqrt(<数値列>)

返り値
Numeric

例
sqrt(X1) X1列の平方根の値を返します

X1 NEW
9 3
7 2.645751311
4 2

sum

概要
すべての値の合計値を返します。

シンタックス
sum(<数値またはロジカル型の列>, na.rm = <TRUEまたはFALSE>)

引数

返り値
Numeric

例
sum(売上)
売上の合計値を返します。主に集計の際に使用されますが、計算を作成でも使用することができます。

tan

概要
指定された角度のタンジェントをラジアン単位で返します。

シンタックス
tan(<数値列>)

返り値
Numeric

例
tan(X1) X1列に対してtanで計算した値を返します。

X1 NEW
9 -0.4523156594
7 0.8714479827
4 1.157821282

tanh

概要
任意の実数の双曲線正接を返します。

シンタックス
tanh(<数値列>)

返り値
Numeric

例
tanh(X1) X1列に対してtanhで計算した値を返します。

X1 NEW
0.5 0.4621171573
1 0.761594156
10 0.9999999959

tanpi

概要
tan(pi * )を返します。

シンタックス
tanpi(<数値列>)

返り値
Numeric

例
tanpi(X1) X1列に対してtanpiで計算した値を返します。

X1 NEW
0 0
0.25 1
-0.3 -1.37638192

trunc

概要
数値の小数点以下を切り捨てます。

シンタックス
trunc(<数値列>)

返り値
Numeric

例
trunc(X1) X1列に対して小数点以下を切り捨てた値を返します。

X1 AFTER
-314.2684 -314
1.9798 1
23.311785 23

union

概要
複数のデータフレームを結合し、どちらかまたは両方のデータフレームに存在する行を保持します。集合演算の「和集合」に相当します。

シンタックス
union(<データフレーム1>, <データフレーム2>, ...)

引数 データフレーム - 結合したいデータフレームを指定します。複数のデータフレームを指定できます。

例

データ1:

ID 商品名 価格
1 りんご 100
2 みかん 80
3 バナナ 120

データ2:

ID 商品名 価格
2 みかん 80
3 バナナ 120
4 キウイ 150

union(データ1, データ2) データ1とデータ2のいずれか、あるいは両方に存在する行を結合します。

ID 商品名 価格
1 りんご 100
2 みかん 80
3 バナナ 120
4 キウイ 150

unique

概要
一意な値の数を返します。

シンタックス
unique(<列名>, incomparables = <TRUE|FALSE>, fromLast = <TRUE|FALSE>, nmax = <数値>)

引数

返り値
Numeric

例
summarize(text_length = length(unique(TAIL_NUM)))
TAIL_NUMの各グループの一意な値の数を返します。

which

概要
論理ベクトル内の値の位置を返します。

シンタックス
which(<条件>, arr.ind = <TRUE|FALSE>, useNames = <TRUE|FALSE>)

引数

返り値
Numeric

例
x <- c("a", "b", "c", "d", "e")
which(x == "c")
3を返します。
select(which(sapply(., is.numeric)))
数値型の列のみを残します。

xor

概要
2つの値の排他的論理和のチェックを実行し、2つの値のうち1つだけがTRUEの場合のみTRUEを返します。

シンタックス
xor(<TRUE|FALSE>, <TRUE|FALSE>)

返り値
Logical

例
xor(X1, Y1) X1列とY1列の排他的論理和を計算し、いずれか一方がTRUEの場合のみTRUEを返します。

X1 Y1 NEW
TRUE TRUE FALSE
TRUE FALSE TRUE
FALSE TRUE TRUE
FALSE FALSE FALSE

anti_join

概要
現在のデータフレームから、ターゲットのデータフレームに一致する値がない行のみを返します。現在のデータフレームの列だけを保持します。

シンタックス
anti_join(<データフレーム>, by = "<列名>")
anti_join(<データフレーム>, by = c("<元データフレームの列名>" = "<ターゲットデータフレームの列名>"))

引数 * データフレーム - 結合するデータフレームを指定します。 * by (オプション) - 結合する列を指定します。共通の列名または各データフレームから異なる列名を指定できます。

例

データ1 (顧客データ):

ID 名前 年齢
1 田中 25
2 佐藤 30
3 鈴木 22

データ2 (購入データ):

顧客ID 商品 金額
1 テレビ 50000
2 冷蔵庫 80000

anti_join(データ1, データ2, by = c("ID" = "顧客ID")) データ1に存在し、データ2に存在しない顧客の行のみを返します。

ID 名前 年齢
3 鈴木 22

arrange

概要
指定した列の値に基づいて行をソートします。デフォルトでは昇順（小さい値から大きい値）でソートします。

シンタックス
arrange(<列名(複数可)>)

引数 列名 - ソートの基準となる列を指定します。複数の列を指定すると、最初の列でソートし、同じ値がある場合は次の列でソートします。

例

元のデータ:

名前 年齢 身長
田中 25 175
佐藤 30 180
鈴木 25 170

arrange(年齢) 年齢の値に基づいて昇順（小さい値から大きい値）でソートします。

名前 年齢 身長
田中 25 175
鈴木 25 170
佐藤 30 180

arrange(年齢, 身長) 年齢でソートし、同じ年齢の場合は身長で昇順ソートします。

名前 年齢 身長
鈴木 25 170
田中 25 175
佐藤 30 180

arrange(desc(年齢))

年齢の値に基づいて降順（大きい値から小さい値）でソートします。

名前 年齢 身長
佐藤 30 180
田中 25 175
鈴木 25 170

between

概要
注目している値が、指定された範囲内にあるかどうかをもとに、 TRUE または FALSE を返します。

シンタックス
between(<数値列または日付列>, <left>, <right>)

引数

返り値 Logical

例
filter(between(売上, 1000, 6000))
売上が 1000から6000 の間のデータにフィルタします。

bind_cols

概要
複数のデータフレームを列方向に結合します。結合するデータフレームの行数が同じである必要があります。

シンタックス
bind_cols(<データフレーム1>, <データフレーム2>, ...)

引数 データフレーム - 列方向に結合するデータフレームを指定します。複数のデータフレームを指定できます。

例

データ1:

名前 年齢
田中 25
佐藤 30
鈴木 22

データ2:

身長 体重
175 65
180 75
170 60

bind_cols(データ1, データ2) データ1とデータ2を列方向に結合します。

名前 年齢 身長 体重
田中 25 175 65
佐藤 30 180 75
鈴木 22 170 60

bind_rows

概要
複数のデータフレームを行方向に結合します。列名が共通のものは自動的に一致させて結合されます。

シンタックス
bind_rows(<データフレーム1>, <データフレーム2>, ..., .id = <id列名>, current_df_name = <現在のデータフレーム名>, force_data_type = <TRUE|FALSE>, encoding = <エンコーディング>)

引数 * データフレーム - 行方向に結合するデータフレームを指定します。複数のデータフレームを指定できます。リスト形式で複数のデータフレームを指定することも可能です。 * .id (オプション) - データフレームの識別子の列名を指定します。指定すると、その列に元のデータフレームの識別子が入ります。命名された引数から識別子が取得されます。データフレームのリストが供給された場合、リストの名前から識別子が取得されます。名前が見つからない場合は、数値の連番が使用されます。 * current_df_name (オプション) - dplyrのパイプ操作で渡される現在のデータフレームの名前として使用する値を指定します。 * force_data_type (オプション) - TRUEに設定すると、まずすべての列のデータ型を文字型に変換し、結合後に再度推測された値に戻します。 * encoding (オプション) - force_data_type引数がTRUEに設定されている場合に使用されるエンコーディングを指定します。

例

データ1:

名前 年齢
田中 25
佐藤 30

データ2:

名前 年齢 身長
鈴木 22 170
高橋 35 175

bind_rows(データ1, データ2)

データ1とデータ2を行方向に結合します。共通の列は自動的に一致させられ、片方にしかない列は欠損値（NA）で埋められます。

名前 年齢 身長
田中 25 NA
佐藤 30 NA
鈴木 22 170
高橋 35 175

bind_rows(データ1, データ2, .id = "データ元")

データ1とデータ2を行方向に結合し、「データ元」という列を追加してどのデータフレームから来たかを示します。

データ元 名前 年齢 身長
1 田中 25 NA
1 佐藤 30 NA
2 鈴木 22 170
2 高橋 35 175

df_list <- list(社員 = データ1, インターン = データ2) bind_rows(df_list, .id = "種別")

命名されたリストを使用して結合すると、.idに指定した列にリストの名前が入ります。

種別 名前 年齢 身長
社員 田中 25 NA
社員 佐藤 30 NA
インターン 鈴木 22 170
インターン 高橋 35 175

bind_rows(データ1, データ2, force_data_type = TRUE)

データ型の不一致がある場合に、強制的にデータ型を合わせて結合します。まず全ての列を文字型に変換し、結合後に適切なデータ型に戻します。

名前 年齢 身長
田中 25 NA
佐藤 30 NA
鈴木 22 170
高橋 35 175

count

Summary
Summarize the data by either calling n() or sum() for each group.

Syntax
count(<column(s)>, wt = <column_num_or_base_aggregate_expression>, sort = <logical>)

Arguments

Example
count(CARRIER)
Groups by 'CARRIER' and returns the number of rows for each 'CARRIER'.
count(CARRIER, sort = TRUE)
Groups by 'CARRIER' and returns the number of rows for each 'CARRIER' from the highest number to the lowest.
count(CARRIER, wt = ARR_DELAY)
Groups by 'CARRIER' and returns the sum total of 'ARR_DELAY'.
count(CARRIER, TAIL_NUM, wt = ARR_DELAY)
Groups by 'CARRIER' and 'TAIL_NUM', and returns the sum total of 'ARR_DELAY'.
count(CARRIER, wt = ARR_DELAY, sort = TRUE)
Groups by 'CARRIER' and returns the sum total of 'ARR_DELAY' and sorted by the total number.
count(CARRIER, wt = mean(ARR_DELAY, na.rm = TRUE))
Groups by 'CARRIER' and returns the average of 'ARR_DELAY' after removing NA values.

cumall

概要

現在の位置までのすべての値がTRUE のときにTRUE を返します。

シンタックス
cumall(<条件>)

引数

返り値 Logical

例
cumall(X1) X1列の論理値について、各行までのすべての値がTRUEであるかを順番に返します。最初にFALSEが出現した以降はFALSEとなります。

X1 NEW
TRUE TRUE
TRUE TRUE
FALSE FALSE
TRUE FALSE

cumany

概要
現在の位置までの値のいずれかが TRUE ならば TRUE を返します。

シンタックス
cumany(<条件>)

引数

返り値 Logical

例
cumany(X1) X1列の論理値について、各行までにTRUEが1つでもあれば、それ以降すべての行でTRUEを返します。

X1 NEW
FALSE FALSE
TRUE TRUE
FALSE TRUE

cume_dist

概要
その値の順位以下の全値の割合である累積分布を返します。欠測値の場合は、欠損値を返します。

シンタックス
cume_dist(<数値列>)

返り値 Numeric

例
cume_dist(X1) X1列の値について、各値の累積分布（その値以下の値の割合）を返します。

X1 NEW
10 0.33
20 0.67
30 1.00

filter(cume_dist(X1) < .25) X1列の累積分布が0.25未満の行のみを選択します。

X1 Sales NEW
50 20 0.20
60 25 0.24
70 30 0.28

cummean

概要
累積平均を返します。

シンタックス
cummean(<数値列>)

引数

返り値 Numeric

例
cummean(X1) X1列の値について、各行までの平均値を順番に返します。

X1 NEW
1 1.0
2 1.5
3 2.0

dense_rank

概要
隙間のない順位を返します。 欠損値の場合は、欠損値がそのまま残ります。

シンタックス
dense_rank(<数値列>)

返り値 Numeric

例
dense_rank(X1) X1列の値について、順位を返します。同じ値には同じ順位が付与され、次の順位は連続した数値となります。

X1 NEW
10 2
5 1
10 2
15 3
10 2

filter(dense_rank(X1) < 3) X1列の値について、順位が3未満の行のみを選択します。

X1 NEW
10 10
5 5
10 10
15 （フィルタされます）
10 10

desc

概要
並び替え（ソート）の順序を降順に変更します。例えば、1から9の代わりに9から1へ、aからzの代わりにzからaへといった順序になります。

シンタックス
desc(<列名>)

例

元のデータ:

製品 売上 利益
A製品 1200 300
B製品 950 200
C製品 1500 450

arrange(desc(売上)) 売上列を基準に降順（大きい値から小さい値）で並べ替えます。

製品 売上 利益
C製品 1500 450
A製品 1200 300
B製品 950 200

arrange(desc(売上), desc(利益)) 売上列を基準に降順でソートし、売上が同じ場合は利益も降順でソートします。

製品 売上 利益
C製品 1500 450
A製品 1200 300
B製品 950 200

distinct

概要
重複する行を削除し、ユニークな行のみを保持します。デフォルトでは最初に現れた行のみが残されます。.keep_all引数をTRUEに設定すると、指定した列でユニークな行のすべての列を保持できます。

シンタックス
distinct(<列名(複数可)>, .keep_all = <論理値>)

引数 * 列名(複数可) - 重複を判定するための列を指定します。省略すると、すべての列に基づいて重複を判定します。 * .keep_all - デフォルトはFALSEです。TRUEに設定すると、指定した列に基づいて重複を判定した後、すべての列を保持します。

例

元のデータ:

部署 名前 年齢 給与
営業 田中 25 250000
開発 佐藤 30 300000
営業 鈴木 28 270000
開発 佐藤 30 300000

distinct() すべての列に基づいて重複を削除します。

部署 名前 年齢 給与
営業 田中 25 250000
開発 佐藤 30 300000
営業 鈴木 28 270000

distinct(部署, 名前) 部署と名前に基づいて重複を削除し、最初に現れた行の部署と名前のみを保持します。

部署 名前
営業 田中
開発 佐藤
営業 鈴木

distinct(部署, 名前, .keep_all = TRUE) 部署と名前に基づいて重複を削除しますが、すべての列を保持します。

部署 名前 年齢 給与
営業 田中 25 250000
開発 佐藤 30 300000
営業 鈴木 28 270000

filter

概要
条件に基づいてデータフレームから行を選択します。

シンタックス
filter(<条件>)

引数

返り値
Data Frame

例
filter(revenue < 6000) revenueが6000未満の行だけを保持します。

filter(revenue < 6000 & region == "West") revenueが6000未満かつregionが"West"の行だけを保持します。

filter(revenue < 6000 | region == "West") revenueが6000未満、またはregionが"West"の行を保持します。

filter(between(revenue, 1000, 6000)) revenueが1000から6000の範囲内の行だけを保持します。

filter(is.na(revenue)) revenueがNA（欠損値）の行だけを保持します。

filter(!is.na(revenue)) revenueがNA（欠損値）でない行だけを保持します。

filter(!is_empty(comments)) comments列が空（空文字）でない行だけを保持します。

first

概要
最初の値を返します。

シンタックス
first(<列名>, order_by = <列名>, default = <文字列>)

引数

例
summarize( 最初の名前 = first(名前))
各グループの最初の値を返す新しい列を作成します。

full_join

概要
現在のデータフレームとターゲットのデータフレームの両方からすべての行とすべての列を返します。結合に一致しない場合、欠損値（NA）が使われます。これは外部結合（FULL OUTER JOIN）と呼ばれる操作です。

シンタックス
full_join(<データフレーム>, by = "<列名>", suffix = c("<元データフレームの接尾辞>", "<ターゲットデータフレームの接尾辞>"))
full_join(<データフレーム>, by = c("<元データフレームの列名>" = "<ターゲットデータフレームの列名>"), suffix = c("<元データフレームの接尾辞>", "<ターゲットデータフレームの接尾辞>"))

引数 * データフレーム - 結合するデータフレームを指定します。 * by (オプション) - 結合する列を指定します。共通の列名または各データフレームから異なる列名を指定できます。省略すると、共通の列名をすべて使って結合します。 * suffix - デフォルトは c(".x", ".y") です。両方のデータフレームに結合されない重複した変数がある場合、これらの接尾辞が出力に追加されて列名の衝突を避けます。

例

元のデータ1 (注文):

注文ID 顧客ID 商品ID 数量
1 101 A001 2
2 102 A002 1
3 103 A001 3

元のデータ2 (顧客):

顧客ID 名前 地域
101 田中 東京
102 佐藤 大阪
104 高橋 名古屋

full_join(注文, 顧客, by = "顧客ID") 注文データと顧客データを顧客IDで結合します。どちらかのデータフレームにしか存在しない行も含めてすべての行を返します。

注文ID 顧客ID 商品ID 数量 名前 地域
1 101 A001 2 田中 東京
2 102 A002 1 佐藤 大阪
3 103 A001 3 NA NA
NA 104 NA NA 高橋 名古屋

full_join(注文, 顧客, by = c("顧客ID"), suffix = c("_注文", "_顧客")) 接尾辞を指定して結合すると、重複する列名を区別できます。この例では重複列がないため結果は同じですが、重複した列がある場合に効果があります。

注文ID 顧客ID 商品ID 数量 名前 地域
1 101 A001 2 田中 東京
2 102 A002 1 佐藤 大阪
3 103 A001 3 NA NA
NA 104 NA NA 高橋 名古屋

full_join(注文,顧客, by = c("注文ID" = "顧客ID")) 異なる列名で結合する場合は、列名のマッピングを指定します。この例では注文IDと顧客IDで結合しています（実際のデータでは適切でないかもしれませんが、構文の例として示しています）。

注文ID/顧客ID 顧客ID 商品ID 数量 名前 地域
1 101 A001 2 田中 NA
2 102 A002 1 佐藤 NA
3 103 A001 3 NA NA
104 NA NA NA 高橋 名古屋

funs

Summary
funs provides a flexible way to generate a named list of functions for input to other functions like summarise_each.

Syntax
funs(<function_name(s)>)

Arguments

A list of functions specified by: * Their name, "mean" * The function itself, mean * A call to the function with . as a dummy parameter, mean(., na.rm = TRUE)

Example
funs(mean, "mean", mean(., na.rm = TRUE))
# Override default names
funs(m1 = mean, m2 = "mean", m3 = mean(., na.rm = TRUE))

group_by

概要
データフレームをグループ化されたデータフレームに変換します。グループ化すると、それ以降の操作がグループごとに実行されます。集計操作を行う前にグループ化する必要があります。

シンタックス
group_by(<列名(複数可)>)

引数 * 列名(複数可) - グループ化の基準となる列を指定します。複数の列を指定すると、それらの列の組み合わせでグループ化されます。

例

元のデータ:

部署 名前 売上
営業 田中 100
営業 佐藤 150
開発 鈴木 200
開発 高橋 180
営業 山田 120

group_by(部署) データを部署列でグループ化します。見た目は変わりませんが、内部的にはグループ化された状態になります。

部署 名前 売上
営業 田中 100
営業 佐藤 150
営業 山田 120
開発 鈴木 200
開発 高橋 180

group_by(部署) %>% summarize(平均売上 = mean(売上)) 部署でグループ化した後に、部署ごとの平均売上を計算します。

部署 平均売上
営業 123.3
開発 190.0

group_by(部署, 名前) 複数の列でグループ化することもできます。部署と名前の組み合わせでグループ化されます。

部署 名前 売上
営業 田中 100
営業 佐藤 150
営業 山田 120
開発 鈴木 200
開発 高橋 180

inner_join

概要
現在のデータフレームと対象データフレームの両方に一致する値がある行だけを返します。現在のデータフレームと対象データフレームの両方の列が返されます。これはSQL文の「INNER JOIN」に相当します。

シンタックス
inner_join(<データフレーム>, by = "<列名>", suffix = c("<元データフレームの接尾辞>", "<ターゲットデータフレームの接尾辞>"))
inner_join(<データフレーム>, by = c("<元データフレームの列名>" = "<ターゲットデータフレームの列名>"), suffix = c("<元データフレームの接尾辞>", "<ターゲットデータフレームの接尾辞>"))

引数 * データフレーム - 結合するデータフレームを指定します。 * by (オプション) - 結合する列を指定します。共通の列名または各データフレームから異なる列名を指定できます。省略すると、共通の列名をすべて使って結合します。 * suffix - デフォルトは c(".x", ".y") です。両方のデータフレームに結合されない重複した変数がある場合、これらの接尾辞が出力に追加されて列名の衝突を避けます。

例
元のデータ1 (注文):

注文ID 顧客ID 商品ID 数量
1 101 A001 2
2 102 A002 1
3 103 A001 3

元のデータ2 (顧客):

顧客ID 名前 地域
101 田中 東京
102 佐藤 大阪
104 高橋 名古屋

inner_join(顧客, by = "顧客ID") 両方のデータフレームに存在する顧客IDを持つ行のみを返します。

注文ID 顧客ID 商品ID 数量 名前 地域
1 101 A001 2 田中 東京
2 102 A002 1 佐藤 大阪

lag

概要
注目している値より前の値を返します。

シンタックス
lag(<列>, n = <数値>, default = <文字列>, order_by = <単一または複数列>)

引数

例
lag(X1) X1列の値について、1行前の値を返します。最初の行はNAとなります。

X1 NEW
1 NA
2 1
3 2

lag(X1, 2) X1列の値について、2行前の値を返します。最初の2行はNAとなります。

X1 NEW
1 NA
2 NA
3 1

last

概要
最後の値を返します。

シンタックス
last(<列名>, order_by = <列名>, default = <文字列>)

引数

例
last(X1) X1列の最後の値を返します。グループ化されている場合は、各グループの最後の値を返します。

X1 NEW
Red Green
Blue Green
Green Green

lead

概要
注目している値よりも後の値を返します。

シンタックス
lead(<列>, n = <数値>, default = <文字列>, order_by = <単一または複数列>)

引数

例 lead(X1) X1列の値について、1行後の値を返します。最後の行はNAとなります。

X1 NEW
1 2
2 3
3 NA

lead(X1, 2) X1列の値について、2行後の値を返します。最後の2行はNAとなります。

X1 NEW
1 3
2 NA
3 NA

left_join

概要
左外部結合（LEFT JOIN）を実行します。現在のデータフレーム（左側）のすべての行と、現在のデータフレームとターゲットデータフレーム（右側）からすべての列を返します。左側のデータフレームの行に右側のデータフレームで一致するものがない場合、右側から追加される列にはNA値が入ります。複数の一致がある場合は、すべての組み合わせが返されます。

シンタックス
left_join(<データフレーム>, by = "<列名>", suffix = c("<元データフレームの接尾辞>", "<ターゲットデータフレームの接尾辞>"))
left_join(<データフレーム>, by = c("<元データフレームの列名>" = "<ターゲットデータフレームの列名>"), suffix = c("<元データフレームの接尾辞>", "<ターゲットデータフレームの接尾辞>")) left_join(<データフレーム>, by = join_by(<元データフレームの列名> == <ターゲットデータフレームの列名>), na_matches = "never")

引数 * データフレーム - 結合するデータフレームを指定します。 * by (オプション) - 結合する列を指定します。共通の列名または各データフレームから異なる列名を指定できます。省略すると、共通の列名をすべて使って結合します。 * suffix (オプション) - デフォルトは c(".x", ".y") です。両方のデータフレームに結合されない重複した変数がある場合、これらの接尾辞が出力に追加されて列名の衝突を避けます。 * na_matches (オプション) - 欠損値を結合キーとしてマッチ（一致）させるかどうかを指定します。デフォルトは "never" で、欠損値同士をマッチさせません。"na" を指定すると、欠損値もマッチする結合キーとして扱い、欠損値同士をマッチさせます。

例
元のデータ:

顧客ID 顧客名 注文額
101 山田 5000
102 鈴木 3000
103 佐藤 7000

顧客属性データ:

顧客ID 地域 年齢
101 東京 35
102 大阪 42
104 福岡 28

left_join(顧客属性, by = "顧客ID") 元のデータフレームの全ての行を保持しながら、「顧客ID」列をキーに「顧客属性」のデータフレームを結合します。結合先に一致する値がない「顧客ID」=103の行では、地域と年齢にNA値が入ります。

顧客ID 顧客名 注文額 地域 年齢
101 山田 5000 東京 35
102 鈴木 3000 大阪 42
103 佐藤 7000 NA NA

left_join(顧客属性, by = c("顧客ID" = "顧客ID")) 元のデータフレームの全ての行を保持しながら、「顧客ID」列をキーに「顧客属性」のデータフレームを結合します。列名が同じ場合は単純に列名を指定できますが、c()表記でも動作します。

顧客ID 顧客名 注文額 地域 年齢
101 山田 5000 東京 35
102 鈴木 3000 大阪 42
103 佐藤 7000 NA NA

left_join(顧客属性, by = c("顧客ID" = "顧客ID"), suffix = c("_元", "_新")) 元のデータフレームの全ての行を保持しながら、「顧客ID」列をキーに「顧客属性」のデータフレームを結合します。同名の列があった場合、suffix引数で指定した接尾辞が付与されます。この例では列名が異なるので変化はありません。

顧客ID 顧客名 注文額 地域 年齢
101 山田 5000 東京 35
102 鈴木 3000 大阪 42
103 佐藤 7000 NA NA

元のデータ（従業員）:

従業員ID 職種コード 氏名
1 A01 高橋
2 A02 田中
3 NA 伊藤

職種データ:

職種コード 職種名
A01 営業
A02 開発
NA 未定

left_join(職種, by = join_by(職種コード == 職種コード))` 元のデータフレームの全ての行を保持しながら、「職種コード」列をキーに「職種」のデータフレームを結合します。この場合、デフォルトではNA値は一致しません。

従業員ID 職種コード 氏名 職種名
1 A01 高橋 営業
2 A02 田中 開発
3 NA 伊藤 NA

left_join(職種, by = join_by(職種コード == 職種コード), na_matches = "na") 元のデータフレームの全ての行を保持しながら、「職種コード」列をキーに「職種」のデータフレームを結合します。欠損値（NA）も結合キーとして利用します。

従業員ID 職種コード 氏名 職種名
1 A01 高橋 営業
2 A02 田中 開発
3 NA 伊藤 未定

min_rank

概要
隙間のある順位を返します。同じ順位のときには、最小の順位を返します。 欠損値の場合は、欠損値がそのまま残ります。

シンタックス
min_rank(<数値列>)

返り値 Numeric

例
min_rank(X1) X1列の値について、昇順でのランクを返します。同じ値には同じランクが付与され、次のランクは値の数だけ増加します。

X1 NEW
10 3
5 1
10 3
15 5
8 2

min_rank(desc(X1)) X1列の値について、降順でのランクを返します。同じ値には同じランクが付与され、次のランクは値の数だけ増加します。

X1 NEW
10 2
5 5
10 2
15 1
8 4

filter(min_rank(X1) < 3) X1列の値について、ランクが3未満の行のみを選択します。

X1 NEW
10 3（フィルタされます）
5 1
10 3（フィルタされます）
15 5（フィルタされます）
8 2

mutate

概要
mutate関数は、既存の列を保持したまま、指定した式に基づいて新しい列を作成します。複数の列を一度に作成することも可能です。既存の列を削除しながら新しい列を作成したい場合は、transmute関数を代わりに使用できます。

シンタックス
mutate(<新しい列名> = <式>, ...)

引数 * 新しい列名 - 作成する新しい列の名前を指定します * 式 - 新しい列の値を計算するための式を指定します * ... - 複数の列を同時に作成する場合、追加の列名と式のペアを指定します

例

mutate(利益 = 売上 - 費用) 売上列と費用列から「利益」という新しい列を計算して追加します。

商品 売上 費用 利益
A 1000 600 400
B 1500 800 700
C 2000 1200 800

mutate(利益 = 売上 - 費用, 利益率 = (売上 - 費用) / 売上 * 100) 複数の新しい列を一度に作成します。「利益」と「利益率」の両方を計算します。

商品 売上 費用 利益 利益率
A 1000 600 400 40.0
B 1500 800 700 46.7
C 2000 1200 800 40.0

mutate(売上区分 = ifelse(売上 > 1500, "高", "低")) 条件に基づいて新しいカテゴリー列を作成します。売上が1500を超える場合は「高」、それ以外は「低」とします。

商品 売上 費用 売上区分
A 1000 600 低
B 1500 800 低
C 2000 1200 高

n

概要
各グループの行数を返します。

シンタックス
n()

引数

返り値 Numeric

例
summarize(total = n())
各グループの行数を計算するための新しい列を作成します。

n_distinct

概要
一意な値の数を返します。

シンタックス
n_distinct(<列名>, na.rm = <TRUE|FALSE>)

引数

返り値 Numeric

例
summarize(total = n_distinct(TAIL_NUM))
グループごとのTAIL_NUMの一意な値の数を計算する新しい列を作成します。

summarize(total = n_distinct(州, 街))
グループごとの州と街の一意な組み合わせの数を計算する新しい列を作成します。

nth

概要
n番目の値を返します。

シンタックス
nth(<列名>, n = <数値>, order_by = <列名>, default = <文字列>)

引数

例
summarize(total = nth(name, 5))
各グループの5番目の値を返します。

summarize(total = nth(name, -5))
各グループの最後から5番目の値を返します。

ntile

概要

データを指定した数（n）のグループに「等頻度」（各グループの行数がほぼ同じ）になるように分割し、各行がどのグループに属するかを示す整数値（1からnまで）を返します。 この「等頻度での分割」は、分けられた各グループの行数が均等になるように分けるため、等幅（同じ数値の幅）での分割とは異なる処理であることに注意が必要です。

シンタックス
ntile(<対象の列>, <分割数>)

引数

返り値 Numeric

例

ntile(売上金額, 4)

「売上金額」を4つの等頻度グループに分けます。これは各グループに同じ行数が含まれるようにデータを分割します。例えば、全体が8行なら各グループに2行ずつ入ります。

ID 売上金額 四分位グループ
1 10000 1
2 15000 1
3 20000 2
4 25000 2
5 30000 3
6 35000 3
7 40000 4
8 45000 4

percent_rank

概要
0から1間で順位比率を返します。 欠損値の場合は、欠損値がそのまま残ります。

シンタックス
percent_rank(<数値列>)

返り値 Numeric

例
percent_rank(X1) X1列の値について、0から1の間の順位比率を返します。最小値は0、最大値は1となります。

X1 NEW
10 0
20 0.25
30 0.50
40 0.75
50 1

filter(percent_rank(X1) < .25) X1列の値について、順位比率が0.25未満の行のみを選択します。

X1 NEW
10 0
20 0.25
30 （フィルタされます）
40 （フィルタされます）
50 （フィルタされます）

rename

概要
データフレーム内の既存の列名を変更します。複数の列名を一度に変更することも可能です。

シンタックス
rename(<新しい列名> = <既存の列名>, ...)

引数 * 新しい列名 - 変更後の列名を指定します * 既存の列名 - 変更したい列の現在の名前を指定します * ... - 複数の列名を変更する場合は、追加の新しい列名と既存の列名のペアを指定します

例

元のデータ:

ID 名前 年齢
1 佐藤 30
2 鈴木 25
3 田中 40

rename(氏名 = 名前) 「名前」列を「氏名」に名前変更します。

ID 氏名 年齢
1 佐藤 30
2 鈴木 25
3 田中 40

元のデータ:

ID 名前 年齢
1 佐藤 30
2 鈴木 25
3 田中 40

rename(氏名 = 名前, 年数 = 年齢) 複数の列名を一度に変更します。「名前」を「氏名」に、「年齢」を「年数」に変更します。

ID 氏名 年数
1 佐藤 30
2 鈴木 25
3 田中 40

right_join

概要
結合先のデータフレームの全ての行と、現在のデータフレームおよび結合先の全ての列を返します。結合先のデータフレームにおいて現在のデータフレームに一致する値がない行では、現在のデータフレームの列にNA値が入ります。left_joinの逆の動作をします。

シンタックス
right_join(<データフレーム>, by = "<列名>", suffix = c("<元データのサフィックス>", "<結合データのサフィックス>"))
right_join(<データフレーム>, by = c("<元データの列名>" = "<結合データの列名>"), suffix = c("<元データのサフィックス>", "<結合データのサフィックス>"))

引数 * by (オプショナル) - 共通の列名または各データフレームの異なる列名を設定して結合します。 * suffix - デフォルトは c(".x", ".y") です。結合後に同名の列がある場合、列名の曖昧さを避けるために、これらのサフィックスが出力に追加されます。

例

元のデータ:

顧客ID 顧客名 注文額
101 山田 5000
102 鈴木 3000
103 佐藤 7000

顧客属性データ:

顧客ID 地域 年齢
101 東京 35
102 大阪 42
104 福岡 28

right_join(顧客属性, by = "顧客ID") 結合先のデータフレーム（顧客属性）の全ての行を保持しながら、「顧客ID」列を基準に現在のデータフレームを結合します。現在のデータフレームに一致する値がない「顧客ID」=104の行では、顧客名と注文額にNA値が入ります。 | 顧客ID | 顧客名 | 注文額 | 地域 | 年齢 | |--------|--------|--------|------|------| | 101 | 山田 | 5000 | 東京 | 35 | | 102 | 鈴木 | 3000 | 大阪 | 42 | | 104 | NA | NA | 福岡 | 28 |

right_join(顧客属性, by = c("顧客ID" = "顧客ID")) 列名が同じ場合は単純に列名を指定できますが、c()表記でも動作します。

顧客ID 顧客名 注文額 地域 年齢
101 山田 5000 東京 35
102 鈴木 3000 大阪 42
104 NA NA 福岡 28

right_join(顧客属性, by = c("顧客ID" = "顧客ID"), suffix = c("_元", "_新")) 同名の列があった場合、suffix引数で指定した接尾辞が付与されます。この例では列名が異なるので変化はありません。

顧客ID 顧客名 注文額 地域 年齢
101 山田 5000 東京 35
102 鈴木 3000 大阪 42
104 NA NA 福岡 28

row_number

概要
行番号を返します。

シンタックス
row_number()

引数

返り値 Numeric

例
row_number() 各行に行番号を返します。

X1 NEW
10 1
20 2
30 3

sample_frac

概要
sample_frac関数は、データフレームからランダムな割合の行をサンプリングします。例えば、データの20%をランダムに抽出したい場合などに使用します。

シンタックス
sample_frac(<割合>, weight = <数値列>, replace = <論理値>)

引数 * 割合 - 0から1の間の数値です。サンプリングする行の割合を指定します * weight (オプショナル) - サンプリングの重みづけに使用する列を指定します。この値が大きいほど選ばれる確率が高くなります * replace (オプショナル) - デフォルトはFALSEです。TRUEを指定すると、重複を許容してサンプリングします

例

元のデータ（10行）:

ID 名前 売上
1 A商品 1000
2 B商品 1500
3 C商品 2000
4 D商品 1200
5 E商品 1800
6 F商品 900
7 G商品 2200
8 H商品 1600
9 I商品 1400
10 J商品 1700

sample_frac(0.5) データの50%をランダムに抽出します。

ID 名前 売上
2 B商品 1500
4 D商品 1200
5 E商品 1800
8 H商品 1600
9 I商品 1400

sample_frac(0.3, weight = 売上) 「売上」列の値に重み付けして、データの30%をサンプリングします。売上の大きい行が選ばれやすくなります。

ID 名前 売上
3 C商品 2000
7 G商品 2200
10 J商品 1700

sample_frac(0.2, replace = TRUE) データの20%を、重複を許可してサンプリングします。同じ行が複数回選ばれる可能性があります。

ID 名前 売上
5 E商品 1800
5 E商品 1800

sample_n

概要
sample_n関数は、データフレームから指定した行数をランダムにサンプリングします。例えば、データから100行をランダムに抽出したい場合などに使用します。

シンタックス
sample_n(<行数>, weight = <数値列>, replace = <論理値>)

引数 * 行数 - サンプリングする行数を指定します * weight (オプショナル) - サンプリングの重みづけに使用する列を指定します。この値が大きいほど選ばれる確率が高くなります * replace (オプショナル) - デフォルトはFALSEです。TRUEを指定すると、重複を許容してサンプリングします

例

元のデータ（10行）:

ID 名前 売上
1 A商品 1000
2 B商品 1500
3 C商品 2000
4 D商品 1200
5 E商品 1800
6 F商品 900
7 G商品 2200
8 H商品 1600
9 I商品 1400
10 J商品 1700

sample_n(3) データから3行をランダムに抽出します。

ID 名前 売上
3 C商品 2000
6 F商品 900
10 J商品 1700

sample_n(2, weight = 売上) 「売上」列の値に重み付けして、2行をサンプリングします。売上の大きい行が選ばれやすくなります。

ID 名前 売上
7 G商品 2200
3 C商品 2000

sample_n(4, replace = TRUE) 4行を、重複を許可してサンプリングします。同じ行が複数回選ばれる可能性があります。

ID 名前 売上
2 B商品 1500
8 H商品 1600
2 B商品 1500
5 E商品 1800

select

概要
データフレームから指定した列を選択します。列名を直接指定する以外にも、starts_with()、ends_with()、contains()などの関数を使って列を選択することができます。不要な列を除外するために、列名の前にマイナス記号（-）をつけることもできます。

シンタックス
select(<列名(s)>, ...)
select(-<列名(s)>, ...)
select(starts_with(<文字列>, ignore.case = <論理値>))
select(ends_with(<文字列>, ignore.case = <論理値>))
select(contains(<文字列>, ignore.case = <論理値>))
select(matches(<文字列>, ignore.case = <論理値>))
select(num_range(<文字列>, <開始数値>:<終了数値>))
select(any_of(<文字列1>, <文字列2>, ...))
select(<列名>, everything())

引数 * 列名(s) - 選択または除外する列名を指定します * ... - 複数の列や選択条件を指定できます * ignore.case - ヘルパー関数で大文字小文字を区別するかどうかを指定します（デフォルトはTRUE）

例

元のデータ:

商品ID 商品名 価格 カテゴリ 在庫数
A001 りんご 100 果物 200
B002 バナナ 150 果物 150
C003 キャベツ 120 野菜 300

select(商品名, 価格) 「商品名」と「価格」の列だけを選択します。

商品名 価格
りんご 100
バナナ 150
キャベツ 120

元のデータ:

商品ID 商品名 価格 カテゴリ 在庫数
A001 りんご 100 果物 200
B002 バナナ 150 果物 150
C003 キャベツ 120 野菜 300

select(-カテゴリ, -在庫数) 「カテゴリ」と「在庫数」の列を除外します。

商品ID 商品名 価格
A001 りんご 100
B002 バナナ 150
C003 キャベツ 120

元のデータ:

item_id item_name item_price category stock
A001 りんご 100 果物 200
B002 バナナ 150 果物 150
C003 キャベツ 120 野菜 300

select(starts_with("item")) 「item」で始まる列名の列だけを選択します。

item_id item_name item_price
A001 りんご 100
B002 バナナ 150
C003 キャベツ 120

semi_join

概要
結合先のデータフレームに一致する値がある現在のデータフレームの行だけを返します。返される列は現在のデータフレームの列だけで、結合先のデータフレームの列は含まれません。inner_joinとは異なり、一致する行が複数あっても重複は発生しません。

シンタックス
semi_join(<データフレーム>, by = "<列名>")
semi_join(<データフレーム>, by = c("<元データの列名>" = "<結合データの列名>"))

引数 * by (オプショナル) - 共通の列名または各データフレームの異なる列名を設定して結合します

例

元のデータ（商品データ）:

商品ID 商品名 価格
A001 りんご 100
B002 バナナ 150
C003 キャベツ 120
D004 ドリアン 500

販売データ:

販売ID 商品ID 販売数
S001 A001 5
S002 B002 3
S003 A001 2

semi_join(販売データ, by = "商品ID") 販売データに存在する商品IDを持つ商品だけを選択します。商品IDが「A001」と「B002」の行のみが返されます。

商品ID 商品名 価格
A001 りんご 100
B002 バナナ 150

元のデータ（商品データ）:

商品コード 商品名 価格
A001 りんご 100
B002 バナナ 150
C003 キャベツ 120
D004 ドリアン 500

販売データ:

販売ID 商品ID 販売数
S001 A001 5
S002 B002 3
S003 A001 2

semi_join(販売データ, by = c("商品コード" = "商品ID")) 列名が異なる場合、対応関係を指定して結合します。「商品コード」と「商品ID」が一致する行のみが返されます。

商品コード 商品名 価格
A001 りんご 100
B002 バナナ 150

slice

概要
行の位置を指定してデータフレームから行を選択します。

シンタックス
slice(<数値>)
slice(<数値>:<数値>)

引数 * 数値 - 選択したい行の位置（インデックス）を指定します

例

元のデータ:

ID 名前 得点
1 田中 85
2 鈴木 92
3 佐藤 78
4 高橋 64
5 伊藤 90

slice(1) 1行目だけを選択します。filter(row_number() == 1) と同等です。

ID 名前 得点
1 田中 85

slice(3:5) 3行目から5行目までを選択します。filter(between(row_number(), 3, 5)) と同等です。

ID 名前 得点
3 佐藤 78
4 高橋 64
5 伊藤 90

slice(n()) 最後の行だけを選択します。filter(row_number() == n()) と同等です。

ID 名前 得点
5 伊藤 90

summarize

概要
列の値を集計関数を使って単一の値にまとめます。一般的にgroup_by()と組み合わせて使用し、グループごとの統計量を計算します。

シンタックス
summarize(<新しい列名> = <集計式>, ...)

引数 * 新しい列名 - 集計結果を格納する新しい列の名前を指定します * 集計式 - 集計方法を指定します。sum(), mean(), median(), min(), max(), n()などの集計関数を使用できます * ... - 複数の集計列を定義できます

例

元のデータ:

地域 商品 売上
東京 A 100
東京 B 150
大阪 A 80
大阪 B 120
名古屋 A 90

summarize(平均売上 = mean(売上)) すべての行の売上の平均値を計算します。グループ化していない場合は、データ全体の平均が計算されます。

平均売上
108

group_by(地域) %>% summarize(平均売上 = mean(売上)) 地域ごとの売上の平均値を計算します。

地域 平均売上
東京 125
大阪 100
名古屋 90

group_by(地域) %>% summarize(平均売上 = mean(売上), 合計売上 = sum(売上), 商品数 = n()) 地域ごとに複数の集計を行います：平均売上、合計売上、および商品数（行数）を計算します。

地域 平均売上 合計売上 商品数
東京 125 250 2
大阪 100 200 2
名古屋 90 90 1

tally

Summary
Summarize the data by either calling n() or sum() on top of the grouped data. group_by() operation should have been done before.

Syntax
tally(wt = <column>, sort = <logical>)

Arguments

Example
tally()
Returns the number of rows for each group.
tally(wt = ARR_DELAY)
Returns the sum total of 'ARR_DELAY' for each group.
tally(wt = ARR_DELAY, sort = TRUE)
Returns the sum total of 'ARR_DELAY' and sorted by the total number.

top_n

概要
top_n関数は、指定した列の値に基づいて、各グループの上位（または下位）n個のデータに絞り込むことができます。

シンタックス
top_n(<数値>, <数値列>)
top_n(<数値>, desc(<数値列>))

引数 * 数値 - 上位何件を取得するかを指定します。正の整数で上位N、負の整数で下位Nを取得します * 数値列 - 順位付けの基準となる列を指定します

例

元のデータ:

国名 人口（百万） GDP（兆円）
日本 126 500
米国 331 2100
中国 1400 1500
インド 1380 300
ドイツ 83 400

top_n(3, 人口（百万）) 人口が多い上位3カ国を選択します。

国名 人口（百万） GDP（兆円）
中国 1400 1500
インド 1380 300
米国 331 2100

top_n(-2, 人口（百万）) 人口が少ない下位2カ国を選択します。これは top_n(2, desc(人口（百万）)) と同等です。

国名 人口（百万） GDP（兆円）
ドイツ 83 400
日本 126 500

group_by(地域) %>% top_n(1, 売上（万円）) 各地域で売上が最も高い店舗を1つずつ選択します。

地域 店舗 売上（万円）
東京 C店 1500
大阪 D店 1100
名古屋 G店 900

transmute

概要
新しい列を追加しながら既存の列を削除します。mutate関数と異なり、明示的に指定した新しい列だけが結果に含まれます。既存の列を保持したまま新しい列を追加したい場合は、mutate関数を使用します。

シンタックス
transmute(<新しい列名> = <式>, ...)

引数 * 新しい列名 - 作成する新しい列の名前を指定します * 式 - 新しい列の値を計算するための式を指定します * ... - 複数の列を同時に作成する場合、追加の列名と式のペアを指定します

例

元のデータ:

商品 売上 費用
A 1000 600
B 1500 800
C 2000 1200

transmute(利益 = 売上 - 費用) 「売上 - 費用」の計算結果から「利益」という新しい列を作成し、「売上」と「費用」列は削除されます。

利益
400
700
800

transmute(商品, 利益 = 売上 - 費用) 「利益」という新しい列を作成し、元の「商品」列も保持します。ただし「売上」と「費用」列は削除されます。

商品 利益
A 400
B 700
C 800

transmute(利益 = 売上 - 費用, 利益率 = (売上 - 費用) / 売上 * 100) 複数の新しい列を作成します。「利益」と「利益率」を計算し、元の列はすべて削除されます。

利益 利益率
400 40.0
700 46.7
800 40.0

ungroup

概要
group_by関数で設定されたグループ化を解除します。グループ化されたデータフレームに対して操作を行った後、グループ化を解除するために使用されます。

シンタックス
ungroup()

引数 なし

例

元のデータ（地域で既にグループ化されている）:

地域 商品 売上
東京 A 100
東京 B 150
大阪 A 80
大阪 B 120
名古屋 A 90

ungroup() 既存のグループ化を解除します。データ自体は変化しませんが、以降の操作はグループごとではなくデータ全体に対して行われます。

地域 商品 売上
東京 A 100
東京 B 150
大阪 A 80
大阪 B 120
名古屋 A 90

ceiling_date

概要
日付・時間を、指定した単位に最も近い日付、または時間に切り上げます。

シンタックス
ceiling_date(<日付・時間型の列>, unit = <単位>)

引数

返り値
Date / POSIXct

例
ceiling_date(X1, unit = "minute") X1列の日付（時間）を分の単位で切り上げます。

X1 NEW
2015-10-01 6:10:15 2015-10-01 6:11:00

ceiling_date(X1, unit = "hour") X1列の日付（時間）を時間の単位で切り上げます。

X1 NEW
2015-10-01 6:10:15 2015-10-01 7:00:00

ceiling_date(X1, unit = "day") X1列の日付（時間）を日の単位で切り上げます。

X1 NEW
2015-10-01 6:10:15 2015-10-02 0:00:00

ceiling_date(X1, unit = "week") X1列の日付（時間）を週の単位で切り上げます。

X1 NEW
2015-10-01 6:10:15 2015-10-04 0:00:00

ceiling_date(X1, unit = "month") X1列の日付（時間）を月の単位で切り上げます。

X1 NEW
2015-10-01 6:10:15 2015-11-01 0:00:00

ceiling_date(X1, unit = "quarter") X1列の日付（時間）を四半期の単位で切り上げます。

X1 NEW
2015-10-01 6:10:15 2016-01-01 0:00:00

ceiling_date(X1, unit = "year") X1列の日付（時間）を年の単位で切り上げます。

X1 NEW
2015-10-01 6:10:15 2016-01-01 0:00:00

date_decimal

概要

年の分数である数値データを日付データに変換します。

シンタックス
date_decimal(<数値列>, tz = <タイムゾーン>)

引数

返り値
POSIXct

例
date_decimal(X1) X1列の10進数表記の年を日付時間型にに変換します。

X1 NEW
2015.953 2015-12-14 20:16:47 UTC
2015.500 2015-07-02 12:00:00 UTC
2015.000 2015-01-01 00:00:00 UTC

day

概要

日付型や日付時間型の値から日の情報を抽出します。

シンタックス
day(<日付型または日付時間型の列>)

返り値
Numeric

例
day(X1) X1列の日付（時間）から日の情報を抽出します。

X1 NEW
2015-10-01 06:15:30 1
2015-10-15 12:30:45 15
2015-10-31 23:59:59 31

days

概要

計算に使用できるように、数値を日の単位に変換します。

シンタックス
days(<数値列>)

返り値
Period

例
X1 + days(3) X1列の3日後の日付時間を返します。

X1 NEW
2015-10-30 06:15:30 UTC 2015-11-02 06:15:30 UTC
2015-09-29 06:15:30 UTC 2015-10-02 06:15:30 UTC
2015-12-31 06:15:30 UTC 2016-01-03 06:15:30 UTC

decimal_date

概要

日付を年の分数に計算し、日付データを数値データに変換します。

シンタックス
decimal_date(<日付列>)

引数

返り値
Numeric

例
decimal_date(X1) X1列の日付を10進年に変換します。

X1 NEW
2015-12-15 2015.953
2015-06-15 2015.452
2015-01-01 2015.000

dmy

概要

日、月、年の順番の文字列または数値データを日付型に変換します。

シンタックス
dmy(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
Date

例
dmy(X1) X1列の文字列を日付型に変換します。

X1 NEW
10-01-2015 2015-1-10
10/01/2015 2015-1-10
Created on 10 1 2015 2015-1-10
1 Oct, 2015 2015-1-10

dmy_hm(X1) X1列の文字列を日時型に変換します。

X1 NEW
Created on 1 10 2015, at 6:10AM 2015-10-01 06:10:00 UTC

dmy_hm(X1, truncated = 1) X1列の文字列を日付時間型に変換します。分の情報が欠けている場合は00分として補完します。

X1 NEW
01-10-2015 06 2015-10-01 06:00:00 UTC

dmy_hm(X1, locale = "English") X1列の英語形式の文字列を日時型に変換します。

X1 NEW
01 Oct 2015 06:00 2015-10-01 06:00:00 UTC

dmy_h

概要

日、月、年、時の順番の文字列のデータを日付時間型に変換します。

シンタックス
dmy_h(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
dmy_h(X1) X1列の文字列を日時型に変換します。

X1 NEW
01-10-2015 06:10 2015-10-01 06:10:00 UTC

dmy_h(X1) X1列の文字列を日時型に変換します。

X1 NEW
Created on 1 10 2015, at 6:10AM 2015-10-01 06:10:00 UTC

dmy_h(X1, truncated = 1) X1列の文字列を日時時間型に変換します。分の情報が欠けている場合は00分として補完します。

X1 NEW
10-01-2015 06 2015-10-01 06:00:00 UTC

dmy_h(X1, locale = "English") X1列の英語形式の文字列を日時型に変換します。

X1 NEW
Oct 01 2015 06 2015-10-01 06:00:00 UTC

dmy_hm

概要

日、月、年、時、分の順番の文字列のデータを日付時間型に変換します。

シンタックス
dmy_hm(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
dmy_hm(X1) X1列の時分を含む文字列を日付時間型に変換します。

X1 NEW
01-10-2015 06:10 2015-10-01 06:10:00 UTC

dmy_hm(X1) X1列の自然言語による時刻表現を日付時間型に変換します。

X1 NEW
Created on 1 10 2015, at 6:10AM 2015-10-01 06:10:00 UTC

dmy_hm(X1, truncated = 1) X1列の文字列を日付時間型に変換します。分の情報が欠けている場合は00分として補完します。

X1 NEW
01-10-2015 06 2015-10-01 06:00:00 UTC

dmy_hm(X1, locale = "English") X1列の英語形式の日時文字列を日付時間型に変換します。

X1 NEW
01 Oct 2015 06:00 2015-10-01 06:00:00 UTC

dmy_hm(X1) X1列の文字列を日付時間型に変換します。

X1 NEW
01-10-2015 06:10 2015-10-01 06:10:00 UTC

dmy_hms

概要

日、月、年、時、分、秒の順番の文字列のデータを日付時間型に変換します。

シンタックス
dmy_hms(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
dmy_hms(X1) X1列の文字列を日付時間型に変換します。時分秒の情報がすべて必要です。

X1 NEW
01-10-2015 06:10:15 2015-10-01 06:10:15 UTC

dmy_hms(X1) X1列の文字列を日付時間型に変換します。スラッシュ区切りの日付にも対応します。

X1 NEW
01/10/2015 06:10:15 2015-10-01 06:10:15 UTC

dmy_hms(X1) X1列の自然言語による日時表現を日付時間型に変換します。

X1 NEW
Created on 1 10 2015, at 06:10:15 AM 2015-10-01 06:10:15 UTC

dmy_hms(X1) X1列の文字列を日付時間型に変換します。秒の情報が欠けているため、NAを返します。

X1 NEW
01-10-2015 06 NA

dmy_hms(X1, truncated = 2) X1列の文字列を日付時間型に変換します。分秒の情報が欠けている場合は00として補完します。

X1 NEW
01-10-2015 06 2015-10-01 06:00:00 UTC

dmy_hms(X1, locale = "English") X1列の英語形式の文字列を日付時間型に変換します。

X1 NEW
01 Oct 2015 06:00:00 2015-10-01 06:00:00 UTC

duration

概要

数値と指定した単位をもとに、秒単位に換算した値を求められます。

シンタックス
duration(<数値列>, units = <単位>)

引数

返り値
Duration

例
duration(X1, "minutes") X1列の分を秒に変換します。

X1 NEW
1.5 90
60 3600
120 7200

dym

概要

日、年、月の順番の文字列または数値データを日付型に変換します。

シンタックス
dym(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
Date

例
dym(X1) X1列の文字列を日付型に変換します。

X1 NEW
01-2015-10 2015-10-01

dym(X1) X1列のスラッシュ区切りの文字列を日付型に変換します。

X1 NEW
01/2015/10 2015-10-01

dym(X1) X1列の自然言語による日付表現を日付型に変換します。

X1 NEW
Created on 1 2015 10 2015-10-01

dym(X1, locale = "English") X1列の英語形式の文字列を日付型に変換します。

X1 NEW
1 2015, Oct 2015-10-01

floor_date

概要

日付・時間を、指定した単位に最も近い日付、または時間に切り捨てます。

シンタックス
floor_date(<日付・時間型の列>, unit = <単位>)

引数

返り値
Date / POSIXct

例
floor_date(X1, unit = "minute") X1列の日付時間を分単位で切り捨てます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 06:10:00 UTC

floor_date(X1, unit = "hour") X1列の日付時間を時間単位で切り捨てます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 06:00:00 UTC

floor_date(X1, unit = "day") X1列の日付時間を日単位で切り捨てます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 00:00:00 UTC

floor_date(X1, unit = "week") X1列の日付時間を週単位で切り捨てます。

X1 NEW
2015-10-01 06:10:15 2015-09-27 00:00:00 UTC

floor_date(X1, unit = "month") X1列の日付時間を月単位で切り捨てます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 00:00:00 UTC

floor_date(X1, unit = "quarter") X1列の日付時間を四半期単位で切り捨てます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 00:00:00 UTC

floor_date(X1, unit = "year") X1列の日付時間を年単位で切り捨てます。

X1 NEW
2015-10-01 06:10:15 2015-01-01 00:00:00 UTC

force_tz

概要

指定したタイムゾーンに修正します。

シンタックス
force_tz(<日付・時間型の列>, tzone = <タイムゾーン>)

引数

返り値
POSIXct

例

force_tz(X1, tzone = "Asia/Tokyo") X1列のタイムゾーンのみを日本標準時(JST)に変更します。時刻の値は変更しません。

X1 NEW
2014-01-01 15:30:00 UTC 2014-01-01 15:30:00 JST
2014-03-15 09:45:00 UTC 2014-03-15 09:45:00 JST
2014-12-31 23:59:59 UTC 2014-12-31 23:59:59 JST

here

概要

設定されているローカルのタイムゾーンの現在時刻を取得します。

シンタックス
here()

返り値
POSIXct

例
here() X1列の現在時刻をタイムゾーン付きで返します。

X1 NEW
here() "2024-11-08 10:00:00 JST"

hm

概要

時と分のデータを期間のデータ型（Period）に変換します。

シンタックス
hm(<列名>, tz = <タイムゾーン>)

引数

返り値
Period

例
hm(X1) X1列の時分の文字列を期間のデータ型（Period）に変換します。

X1 NEW
6:10 22200
12:30 45000
15:45 56700

hms

概要
hms型のデータを作成できます。Hms,difftimeの値を計算で使う際には秒単位で処理されます。

シンタックス
hms(seconds = <数値>, minutes = <数値>, hours = <数値>, days = <数値>)

引数

返り値
hms

例
hms(hours, minutes, seconds) 時、分、秒から期間のデータ型（Period）に変換します。

hours minutes seconds NEW
5 1 20 18080
10 30 45 37845
15 15 0 54900

hour

概要

日付型や日付時間型の値から時間の情報を抽出します。

シンタックス
hour(<日付型または日付時間型の列>)

返り値
Integer

例
r hour(X1) X1列の時刻から時間（0-23）を抽出します。

X1 NEW
2015-10-01 06:15:30 6
2015-10-01 15:45:00 15
2015-10-01 23:59:59 23

hours

概要

計算に使用できるように、数値を時間の単位に変換します。

シンタックス
hours(<数値列>)

返り値
Period

例

` X1 + hours(1) ``` X1列の1時間後を計算します。

X1 NEW
"2015-10-01 23:15:30 UTC" "2015-10-02 00:15:30 UTC"
"2015-10-01 06:15:30 UTC" "2015-10-01 07:15:30 UTC"
"2015-12-31 23:15:30 UTC" "2016-01-01 00:15:30 UTC"

interval

概要

2つの日付間の間隔を秒単位で返します。この結果を使用して、日、週などの特定の単位で除算するか、as.numeric()で数値型に変換することで期間を取得できます。

シンタックス
interval(<日付列>, <日付列>)

返り値
Interval

例
interval(X1, X2) X1列とX2列の2つの日付の間の期間を秒数で計算します。

X1 X2 NEW
2015-10-01 2015-10-18 1468800

interval(X1, X2) %/% days(1) X1列とX2列の2つの日付の間の期間を日数で計算します。

X1 X2 NEW
2015-10-01 2015-10-18 17

interval(X1, X2) %/% weeks(1) X1列とX2列の2つの日付の間の期間を週数で計算します。

X1 X2 NEW
2015-10-01 2015-10-18 2

is.Date

概要

指定したオブジェクトが日付型の場合はTRUEを返します。

シンタックス
is.Date

引数

返り値
Logical

例 mutate_if(is.Date, wday) X1列の日付から曜日情報を抽出します。

X1 NEW
2024-01-01 2
2024-02-14 4
2024-03-31 1

mutate_if(is.Date, wday, label = TRUE) X1列の日付から曜日情報を文字列として抽出します。

X1 NEW
2024-01-01 Mon
2024-02-14 Wed
2024-03-31 Sun

is.difftime

概要

指定したオブジェクトがdifftime型の場合はTRUEを返します。

シンタックス
is.difftime

引数

返り値
Logical

例
is.difftime(X1) X1列のdifftime型（時間差データ型）かどうかをロジカル型（TRUEまたはFALSE）で返します。

X1 NEW
1800 TRUE
3600 TRUE
1200 TRUE

mutate_if(is.difftime, function(x) as.numeric(difftime(x, units = "secs"))) difftime型の列を全て秒数に変換します。

X1 NEW
1 86400
2 172800
0.5 43200

is.duration

概要

指定したオブジェクトがduration型の場合はTRUEを返します。

シンタックス
is.duration

引数

返り値
Logical

例
as.numeric(X1, units="hours") duration型のX1列を時間の単位に変換します。

X1 NEW
10800 3
5400 1.5
900 0.25

is.POSIXct

概要

指定したオブジェクトがPOSIXct型の場合はTRUEを返します。

シンタックス
is.POSIXct

引数

返り値
Logical

例
mutate_if(is.POSIXct, wday) X1列（POSIXct型）から曜日情報を抽出します（1:日曜 ~ 7:土曜）。

X1 NEW
2024-01-01 10:00:00 2
2024-01-02 10:00:00 3
2024-01-03 10:00:00 4

mutate_if(is.POSIXct, wday, label = TRUE) X1列（POSIXct型）から曜日名を抽出します（Sun ~ Sat）。

X1 NEW
2024-01-01 10:00:00 Mon
2024-01-02 10:00:00 Tue
2024-01-03 10:00:00 Wed

isoweek

概要

年の週番号を抽出します。週の開始曜日は月曜日になっています。

シンタックス
isoweek(<日付列>)

返り値
Numeric

例
isoweek(X1) X1列の日付データから週番号を返します。

X1 NEW
2020-01-01 1
2020-03-15 11
2020-12-31 53

mday

概要

日付列から月の日（1-31）を抽出します。

シンタックス
mday(<日付列>)

返り値
Numeric

例
mday(X1) X1列の日付から月の日を抽出します。

X1 NEW
"2015-10-13" 13
"2015-10-14" 14
"2015-10-15" 15

mdy

概要

月、日、年の順番の文字列または数値データを日付型に変換します。

シンタックス
mdy(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
Date

例
mdy(X1) X1列のハイフン区切りの文字列を日付型に変換します。

X1 NEW
01-10-2015 2015-10-01

mdy(X1) X1列のスラッシュ区切りの文字列を日付型に変換します。

X1 NEW
01/10/2015 2015-10-01

mdy(X1) X1列の空白区切りの文字列を日付型に変換します。

X1 NEW
Created on 1 10 2015 2015-10-01

mdy(X1, locale = "English") X1列の英語での日付表記文字列を日付型に変換します。

X1 NEW
Oct, 1 2015 2015-10-01
Oct, 2 2015 2015-10-02
Oct, 3 2015 2015-10-03

mdy_h

概要

月、日、年、時の順番の文字列のデータを日付時間型に変換します。

シンタックス
mdy_h(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
mdy_h(X1) X1列のハイフン区切りの日付文字列を、UTCの日付時間型に変換します。

X1 NEW
10-01-2015 06 2015-10-01 06:00:00 UTC

mdy_h(X1) X1列の自然言語の日付文字列を、UTCの日付時間型に変換します。

X1 NEW
Created on 10 1 2015 6 AM 2015-10-01 06:00:00 UTC

mdy_h(X1, locale = "English") X1列の英語ロケールでの日付文字列を、UTCの日付時間型に変換します。

X1 NEW
Oct 1, 2015 06 AM 2015-10-01 06:00:00 UTC

mdy_hm

概要

月、日、年、時、分の順番の文字列のデータを日付時間型に変換します。

シンタックス
mdy_hm(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
mdy_hm(X1) X1列の日時の文字列をUTCタイムゾーンの日付時間型に変換します。

X1 NEW
"10-01-2015T06:10" "2015-10-01 06:10:00 UTC"

mdy_hm(X1) X1列の自然言語形式の日時の文字列をUTCタイムゾーンの日付時間型に変換します。

X1 NEW
"Created on 10 1 2015, at 6:10 AM" "2015-10-01 06:10:00 UTC"

mdy_hm(X1, locale = "English") X1列の英語ロケールでの日時の文字列をUTCタイムゾーンの日付時間型に変換します。

X1 NEW
"Oct 1, 2015 06:10 AM" "2015-10-01 06:10:00 UTC"

mdy_hms

mdy_hms(X1) X1列の日時の文字列をUTCタイムゾーンの日付時間型に変換します。

X1 NEW
"10-01-2015T06:10:15" "2015-10-01 06:10:15 UTC"
"10/01/2015T06:10:15" "2015-10-01 06:10:15 UTC"
"10-02-2015T07:20:25" "2015-10-02 07:20:25 UTC"

mdy_hms(X1) X1列の自然言語形式の日時の文字列をUTCタイムゾーンの日付時間型に変換します。不完全な時刻情報の場合はNAを返します。 | X1 | NEW | | ---------- | --- | | "Created on 10 1 2015" | "2015-10-01 06:10:15 UTC" | | "10-01-2015 06" | NA | | "Created on 10 3 2015" | "2015-10-03 06:10:15 UTC" |

mdy_hms(X1, truncated = 2) X1列の不完全な時刻情報を含む日時の文字列を、欠損部分を補完してUTCタイムゾーンの日付時間型に変換します。

X1 NEW
"10-01-2015 06" "2015-10-01 06:00:00 UTC"
"10-02-2015 07" "2015-10-02 07:00:00 UTC"
"10-03-2015 08" "2015-10-03 08:00:00 UTC"

mdy_hms(X1, locale = "English") X1列の英語ロケールでの日時の文字列をUTCタイムゾーンの日付時間型に変換します。

X1 NEW
"Oct 1, 2015 06:10:15 AM" "2015-10-01 06:10:15 UTC"
"Oct 2, 2015 07:20:25 AM" "2015-10-02 07:20:25 UTC"
"Oct 3, 2015 08:30:35 AM" "2015-10-03 08:30:35 UTC"

milliseconds

概要

数値をミリ秒に変換してPeriod型として値を返します。

シンタックス
milliseconds(<数値列>)

返り値
Period

例
milliseconds(X1) X1列の数値をミリ秒単位の期間に変換します。

X1 NEW
1 "0.001"
2 "0.002"
3 "0.003"

minute

概要

日付型や日付時間型の値から分の情報を抽出します。

シンタックス
minute(<日付列>)

返り値
Integer

例
minute(X1) X1列の日付時間から分の情報を抽出します。

X1 NEW
2015-10-01 06:15:30 15
2015-10-01 06:25:30 25
2015-10-01 06:35:30 35

minutes

概要

計算に使用できるように、数値を分の単位に変換します。

シンタックス
minutes(<数値列>)

返り値
Period

例
X1 + minutes(13) X1列の時刻に13分を加算します。

X1 NEW
2015-10-01 23:55:30 UTC 2015-10-02 00:08:30 UTC
2015-10-01 06:15:30 UTC 2015-10-01 06:28:30 UTC
2015-12-31 23:50:30 UTC 2016-01-01 00:03:30 UTC

month

概要

日付型や日付時間型の値から月の情報を抽出します。

シンタックス
month(<日付型または日付時間型の列>, label = <logical>, abbr = <logical>, locale = <ロケール>)

引数

返り値
Numeric or Text

例
month(X1) X1列の日付から月の数値を抽出します。

X1 NEW
2015-10-01 06:15:30 10
2023-12-25 12:00:00 12
2024-03-15 09:30:00 3

month(X1, label = FALSE) X1列の日付から月名を抽出します。

X1 NEW
2015-10-01 06:15:30 10月
2023-12-25 12:00:00 12月
2024-03-15 09:30:00 3月

month(X1, label = TRUE, abbr = TRUE) X1列の日付から月の略称を抽出します。

X1 NEW
2015-10-01 06:15:30 10
2023-12-25 12:00:00 12
2024-03-15 09:30:00 3

ms

概要

分と秒のデータを期間のデータ型（Period）に変換します。

シンタックス
ms(<列名>, tz = <タイムゾーン>)

引数

返り値
Period

例
ms(X1) X1列の時分形式の文字列を秒数に変換します。

X1 NEW
10:15 615
11:30 690
12:45 765

myd

概要

月、年、日の順番の文字列または数値データを日付型に変換します。

シンタックス
myd(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
Date

例
myd(X1) X1列の月年日形式の文字列を日付型に変換します。

X1 NEW
01-2015-10 2015-01-10
02-2023-15 2023-02-15
12-2024-25 2024-12-25

myd(X1) X1列の月年日形式の文字列を日付型に変換します。

X1 NEW
01/2015/10 2015-01-10
02/2023/15 2023-02-15
12/2024/25 2024-12-25

myd(X1) X1列の自然言語による日付表現を日付型に変換します。

X1 NEW
Created on 1 2015 10 2015-01-10
Updated on 2 2023 15 2023-02-15
Posted on 12 2024 25 2024-12-25

myd(X1, locale = "English") X1列の英語表記を含む日付の文字列を日付型に変換します。

X1 NEW
Oct, 2015 1 2015-10-01
Dec, 2023 15 2023-12-15
Mar, 2024 25 2024-03-25

now

概要

日付を含む現在時刻を返します。似た関数に'today()'があり、today関数は今日の日付のみを返します。

シンタックス
now(tzone = <タイムゾーン>)

引数

返り値
POSIXct

例
now() 現在の日時をシステムのタイムゾーンで返します。

NEW
2015-12-31 08:04:59 PST

now("GMT") 現在の日時をGMTタイムゾーンで返します。

NEW
2015-12-31 08:04:59 PST

now("America/Los_Angeles") 現在の日時をロサンゼルスのタイムゾーンで返します。

NEW
2015-12-31 00:04:59 PST

parse_date_time

概要

データを日付時間型に変換します。

シンタックス
parse_date_time(<列名>, orders = <日付時間の順序>, locale = <ロケール>, tz = <タイムゾーン>, truncated = <数値>, quiet = <TRUE|FALSE>, exact = <TRUE|FALSE>, lt = <TRUE|FALSE>)

引数

返り値
POSIXct

例
parse_date_time(X1, "mydHMp") X1列の日時の文字列をフォーマット指定して日付時間型に変換します。

X1 NEW
03/15/05 1:30 PM 2015-03-05 13:30:00 PDT
04/20/06 2:45 PM 2016-04-20 14:45:00 PDT
12/25/07 3:15 PM 2017-12-25 15:15:00 PDT

parse_date_time(X1, "HMp") X1列の時刻の文字列をフォーマット指定して日付時間型に変換します（日付部分は0埋め）。

X1 NEW
1:30 PM 0000-01-01 13:30:00 PDT
2:45 PM 0000-01-01 14:45:00 PDT
3:15 PM 0000-01-01 15:15:00 PDT

qday

概要

日付列から四半期の最初の日からの日数（1-92）を抽出します。

シンタックス
qday(<日付列>)

返り値
Numeric

例
qday(X1) X1列の日付から四半期における通算日を返します。

X1 NEW
2020-02-08 39
2020-02-09 40
2020-02-10 41

quarter

概要

日付型や日付時間型の値から四半期の情報を抽出します。

シンタックス
quarter(<日付列>)

返り値
Numeric

例
quarter(X1) X1列の日付から四半期の情報を返します。

X1 NEW
2015-08-01 06:15:30 3
2015-06-16 07:42:29 2
2015-03-01 12:00:00 1

rollback

概要

日付データを前月の末日、またはその月の最初の日に丸め処理します。

シンタックス
rollback(<日付列>, roll_to_first = <TRUE|FALSE>, preserve_hms = <TRUE|FALSE>)

引数

返り値
POSIXct

例
rollback(X1) X1列の日付を前月の最終日に変換します。

X1 NEW
2020-04-03 2020-03-31
2020-05-15 2020-04-30
2020-06-20 2020-05-31

rollback(X1, roll_to_first = TRUE) X1列の日付を当月の初日に変換します。

X1 NEW
2020-04-03 2020-04-01
2020-05-15 2020-05-01
2020-06-20 2020-06-01

rollback(X1, preserve_hms = FALSE) X1列の日時を前月の最終日の0時0分0秒に変換します。

X1 NEW
2020-04-03 09:21:45 2020-03-31 00:00:00
2020-05-15 14:30:20 2020-04-30 00:00:00
2020-06-20 18:45:10 2020-05-31 00:00:00

round_date

概要

日付・時間を、指定した単位に最も近い日付、または時間に丸めます。

シンタックス
round_date(<日付・時間型の列>, unit = <単位>)

引数

返り値
Date / POSIXct

例
round_date(X1, unit = "minute") X1列の日時を分単位で丸めます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 06:10:00 UTC

round_date(X1, unit = "hour") X1列の日時を時間単位で丸めます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 06:00:00 UTC

round_date(X1, unit = "day") X1列の日付（時間）を日単位で丸めます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 00:00:00 UTC

round_date(X1, unit = "week") X1列の日付（時間）を週単位で丸めます。

X1 NEW
2015-10-01 06:10:15 2015-10-04 00:00:00 UTC

round_date(X1, unit = "month") X1列の日付（時間）を月単位で丸めます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 00:00:00 UTC

round_date(X1, unit = "quarter") X1列の日付（時間）を四半期単位で丸めます。

X1 NEW
2015-10-01 06:10:15 2015-10-01 00:00:00 UTC

round_date(X1, unit = "year") X1列の日付（時間）を年単位で丸めます。

X1 NEW
2015-10-01 06:10:15 2016-01-01 00:00:00 UTC

second

概要

日付型や日付時間型の値から秒の情報を抽出します。

シンタックス
second(<日付型または日付時間型の列>)

返り値
Integer

例 second(X1) X1列の日付時間から秒の情報を抽出します。

X1 NEW
2020-10-01 06:15:30 30
2020-10-01 06:15:45 45
2020-10-01 06:15:15 15

seconds

概要

計算に使用できるように、数値を秒の単位に変換します。

シンタックス
seconds(<数値列>)

返り値
Period

例 X1 + seconds(1) X1列の日付時間に1秒を加算します。

X1 NEW
2015-10-01 23:59:59 UTC 2015-10-02 00:00:00 UTC
2015-10-01 06:15:30 UTC 2015-10-01 06:15:31 UTC
2015-12-31 23:59:59 UTC 2016-01-01 00:00:00 UTC

time_length

概要

2つの日付間の正確な期間を計算して数値として値を返します。

シンタックス
time_length(<interval_or_duration>, unit = <unit>)

引数

返り値
Numeric

例
time_length(interval(X1, X2), "day") X1列とX2列の期間を日数で計算します。

X1 X2 NEW
2015-10-01 2015-10-18 17

time_length(interval(X1, X2), "month") X1列とX2列の期間を月数で計算します（小数点あり）。

X1 X2 NEW
2015-10-01 2015-10-18 0.5483871

trunc(time_length(interval(X1, X2), "month")) X1列とX2列の期間を月数で計算し、切り捨てます。

X1 X2 NEW
2015-10-01 2015-10-18 0

round(time_length(interval(X1, X2), "month")) X1列とX2列の期間を月数で計算し、四捨五入します。

X1 X2 NEW
2015-10-01 2015-10-18 1

today

概要

今日の日付を返します。似た関数に'now()'があり、now関数は現在時刻含む今日の日付を返します。

シンタックス
today(tzone = <タイムゾーン>)

引数

返り値
Date

例
today() X1列のタイムゾーンで現在の日付を返します。

NEW
2024-11-08

today("America/Los_Angeles") 現在の日時をロサンゼルスのタイムゾーンで返します。

NEW
2024-11-08

wday

概要

日付列から曜日（1-7）を数値（例: 月曜日は1）、または文字列（例: 日曜日）として返します。文字列はショート（例: 日）、またはロング（例: 日曜日）として返すことができます。

シンタックス
wday(<日付列>, label = <TRUE|FALSE>, abbr = <TRUE|FALSE>, week_start = <数値>, locale = <ロケール>)

引数

返り値
Numeric or Text

例
wday(X1) X1列の日付から曜日を数値(1-7)で取得します。1は日曜日を表します。

X1 NEW
2015-10-01 5

wday(X1, label = TRUE) X1列の日付から曜日を省略形の文字列で取得します。

X1 NEW
2015-10-01 木

wday(X1, label = TRUE, abbr = FALSE) X1列の日付から曜日を完全な文字列で取得します。

X1 NEW
2015-10-01 木曜日

week

概要

日付型や日付時間型の値から1年の週番号を抽出します。第1週の1日目は、曜日に関係なく、常に1月1日から始まります。

シンタックス
week(<日付型または日付時間型の列>)

返り値
Numeric

例
week(X1) X1列の日付から週番号を返します。

X1 NEW
2020-01-01 1
2020-01-05 1
2020-01-08 2

weeks

概要

計算に使用できるように、数値を週の単位に変換します。

シンタックス
weeks(<数値列>)

返り値
Period

例
X1 + weeks(1) X1列の日付（実感）に1週間（7日）を加算します。

X1 NEW
2015-12-28 06:15:30 UTC 2016-01-04 06:15:30 UTC
2015-10-01 06:15:30 UTC 2015-10-08 06:15:30 UTC
2015-02-23 06:15:30 UTC 2015-03-02 06:15:30 UTC

with_tz

概要

指定したタイムゾーンでの日付・時間を返します。

シンタックス
with_tz(<日付・時間型の列>, tzone = <タイムゾーン>)

引数

返り値
POSIXct

例
with_tz(X1, tzone = "Asia/Tokyo") X1列の日時データを指定した東京のタイムゾーンに変換します。

X1 NEW
as.POSIXct("2014-01-01 00:00:00", tz = "UTC") 2014-01-01 09:00:00 JST
as.POSIXct("2014-01-01 12:00:00", tz = "UTC") 2014-01-01 21:00:00 JST
as.POSIXct("2014-01-02 00:00:00", tz = "UTC") 2014-01-02 09:00:00 JST

with_tz(X1) X1列の日時データをシステムのデフォルトタイムゾーンに変換します。

X1 NEW
as.POSIXct("2014-01-01 00:00:00", tz = "UTC") 2014-01-01 09:00:00 JST
as.POSIXct("2014-01-01 12:00:00", tz = "UTC") 2014-01-01 21:00:00 JST
as.POSIXct("2014-01-02 00:00:00", tz = "UTC") 2014-01-02 09:00:00 JST

yday

概要

日付列から年の日（1-366）を抽出します。

シンタックス
yday(<日付列>)

返り値
Numeric

例
yday(X1) X1列の日付から年初からの通算日を返します。

X1 NEW
2015-10-01 274
2015-10-02 275
2015-10-03 276

ydm

概要

年、日、月の順番の文字列または数値データを日付型に変換します。

シンタックス
ydm(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
Date

例
ydm(X1) X1列の日付文字列を日付型に変換します。

X1 NEW
2015-10-01 2015-01-10

ydm(X1) X1列のスラッシュ区切りの日付文字列を日付型に変換します。

X1 NEW
2015/10/01 2015-01-10

ydm(X1) X1列の自然言語の日付文字列を日付型に変換します。

X1 NEW
Created on 2015 10 1 2015-01-10

ydm(X1, locale = "English") X1列の英語ロケールの日付文字列を日付型に変換します。

X1 NEW
2015, 1 Oct 2015-10-01

ydm_h

概要

年、日、月、時の順番の文字列のデータを日付時間型に変換します。

シンタックス
ydm_h(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
ydm_h(X1) X1列の日時文字列を日付時間型に変換します。

X1 NEW
2015-01-10T06 2015-10-01 06:00:00 UTC

ydm_h(X1) X1列のスラッシュ区切りの日時文字列を日付時間型に変換します。

X1 NEW
2015/01/10 06 2015-10-01 06:00:00 UTC

ydm_h(X1) X1列の自然言語の日時文字列を日付時間型に変換します。

X1 NEW
Created on 15-01-10 at 6 AM 2015-10-01 06:00:00 UTC

ydm_h(X1, locale = "English") X1列の英語ロケールの日時文字列を日付時間型に変換します。

X1 NEW
2015 01 Oct, at 6 AM 2015-10-01 06:00:00 UTC

ydm_hm

概要

年、日、月、時、分の順番の文字列のデータを日付時間型に変換します。

シンタックス
ydm_hm(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
ydm_hm(X1) X1列の日時文字列（時分）を日付時間型に変換します。

X1 NEW
2015-01-10 06:10 2015-10-01 06:10:00 UTC

ydm_hm(X1) X1列のスラッシュ区切りの日時文字列（時分）を日付時間型に変換します。

X1 NEW
2015/01/10 06:00 UTC 2015-10-01 06:10:15 UTC

ydm_hm(X1) X1列の自然言語の日時文字列（時分）を日付時間型に変換します。

X1 NEW
Created on 15-01-10 at 06:10 AM 2015-10-01 06:10:00 UTC

ydm_hm(X1, locale = "English") X1列の英語ロケールの日時文字列（時分）を日付時間型に変換します。

X1 NEW
2015 01 Oct, at 6:10 AM 2015-10-01 06:10:00 UTC

ydm_hms

ydm_hms(X1) X1列の日時文字列（時分秒）を日付時間型に変換します。

X1 NEW
2015-01-10T06:10:15 2015-10-01 06:10:15 UTC

ydm_hms(X1) X1列のスラッシュ区切りの日時文字列（時分秒）を日付時間型に変換します。

X1 NEW
2015/01/10 06:10:15 UTC 2015-10-01 06:10:15 UTC

ydm_hms(X1) X1列の自然言語の日時文字列（時分秒）を日付時間型に変換します。

X1 NEW
Created on 15-01-10 at 06:10:15 AM 2015-10-01 06:10:15 UTC

ydm_hms(X1) X1列の不完全な日時文字列は変換に失敗しNAを返します。

X1 NEW
2015-01-10 06 NA

ydm_hms(X1, truncated = 2) X1列の不完全な日時文字列を日付時間型に変換します。

X1 NEW
2015-01-10 06 2015-10-01 06:00:00 UTC

ydm_hms(X1, locale = "English") X1列の英語ロケールの日時文字列（時分秒）を日付時間型に変換します。

X1 NEW
2015 01 Oct, at 6:10:15 AM 2015-10-01 06:10:15 UTC

year

概要

日付型や日付時間型の値から年の情報を抽出します。

シンタックス
year(<日付型または日付時間型の列>)

返り値
Numeric

例
year(X1) X1列の日付から年を抽出します。

X1 NEW
2015-10-01 06:15:30 2015
2016-10-01 06:15:30 2016
2017-10-01 06:15:30 2017

years

概要

計算に使用できるように、数値を年の単位に変換します。

シンタックス
years(<数値列>)

返り値
Period

例 X1 + years(1) X1列の日付（時間）に1年を加算します。

X1 NEW
2015-10-01 06:15:30 UTC 2016-10-01 06:15:30 UTC
2016-02-29 06:15:30 UTC 2017-02-28 06:15:30 UTC
2015-12-31 06:15:30 UTC 2016-12-31 06:15:30 UTC

ymd

概要

年、月、日の順番の文字列または数値データを日付型に変換します。

シンタックス ymd(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
Date

例
ymd(X1) X1列の日付文字列を日付型に変換します。

X1 NEW
2015-10-01 2015-10-01

ymd(X1) X1列のスラッシュ区切りの日付文字列を日付型に変換します。

X1 NEW
2015/10/01 2015-10-01

ymd(X1) X1列の自然言語の日付文字列を日付型に変換します。

X1 NEW
Created on 2015 10 1 2015-10-01

ymd(X1, locale = "English") X1列の英語ロケールの日付文字列を日付型に変換します。

X1 NEW
2015, Oct 1 2015-10-01

ymd_h

概要

年、月、日、時の順番の文字列のデータを日付時間型に変換します。

シンタックス
ymd_h(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例 ymd_h(X1) X1列の日時文字列を日付時間型に変換します。

X1 NEW
2015-10-01T06 2015-10-01 06:00:00 UTC

ymd_h(X1) X1列のスラッシュ区切りの日時文字列を日付時間型に変換します。

X1 NEW
2015/10/01 06 2015-10-01 06:00:00 UTC

ymd_h(X1) X1列の自然言語の日時文字列を日付時間型に変換します。

X1 NEW
Created on 15-10-01 at 6 AM 2015-10-01 06:00:00 UTC

ymd_h(X1, locale = "English") X1列の英語ロケールの日時文字列を日付時間型に変換します。

X1 NEW
2015, Oct 1 6AM 2015-10-01 06:00:00 UTC

ymd_hm

概要

年、月、日、時、分の順番の文字列のデータを日付時間型に変換します。

シンタックス
ymd_hm(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例 ymd_hm(X1) X1列の日時文字列を日付時間型に変換します。

X1 NEW
2015-10-01 06:10 2015-10-01 06:10:00 UTC

ymd_hm(X1) X1列のスラッシュ区切りの日時文字列を日付時間型に変換します。

X1 NEW
2015/10/01 06:00 UTC 2015-10-01 06:10:15 UTC

ymd_hm(X1) X1列の自然言語の日時文字列を日付時間型に変換します。

X1 NEW
Created on 15-10-01 at 06:10 AM 2015-10-01 06:10:00 UTC

ymd_hm(X1, locale = "English") X1列の英語ロケールの日時文字列を日付時間型に変換します。

X1 NEW
2015, Oct 1 06:10 AM 2015-10-01 06:10:00 UTC

ymd_hms

概要

年、月、日、時、分、秒の順番の文字列のデータを日付時間型に変換します。

シンタックス
ymd_hms(<列名>, tz = <タイムゾーン>, locale = <ロケール>, truncated = <数値>)

引数

返り値
POSIXct

例
ymd_hms(X1) X1列の日時文字列を日付時間型に変換します。

X1 NEW
2015-10-01T06:10:15 2015-10-01 06:10:15 UTC

ymd_hms(X1) X1列のスラッシュ区切りの日時文字列を日付時間型に変換します。

X1 NEW
2015/10/01 06:10:15 UTC 2015-10-01 06:10:15 UTC

ymd_hms(X1) X1列の自然言語の日時文字列を日付時間型に変換します。

X1 NEW
Created on 15-10-01 at 06:10:15 AM 2015-10-01 06:10:15 UTC

ymd_hms(X1) X1列の不完全な日時文字列は変換に失敗しNAを返します。

X1 NEW
2015-10-01 06 NA

ymd_hms(X1, truncated = 2) X1列の不完全な日時文字列でもtruncatedを指定すると欠損値を補完して日付時間型に変換します。

X1 NEW
2015-10-01 06 2015-10-01 06:00:00 UTC

ymd_hms(X1, locale = "English") X1列の英語ロケールの日時文字列（時分秒）を日付時間型に変換します。

X1 NEW
2015, Oct 1 06:10:15 AM 2015-10-01 06:10:15 UTC

cor

概要
2つの列の値の相関関係を計算します。共分散を2 つの列の値の標準偏差の積で割ることで計算されます。

シンタックス
cor(<数値列>, <数値列>, use = <欠損値の処理方法>, method = <計算方法>)

引数

例
summarize(相関 = cor(到着遅れ, 出発遅れ))
到着遅れの列と出発遅れの列の相関係数を計算します。

cov

概要
2つの列の値の共分散を計算します。

シンタックス
cov(<数値列>, <数値列>, use = <欠損値の処理方法>, method = <計算方法>)

引数

例
summarize(covariance = cov(到着遅れ, 出発遅れ))
到着遅れの列と出発遅れの列の共分散を計算します。

IQR

概要
四分位範囲を計算します。

シンタックス
IQR(<数値列>, na.rm = <TRUE|FALSE>, type = 1|2|3|4|5|6|7|8|9)

引数

返り値
Numeric

例
// x <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
IQR(x)
4.5を返します

mad

概要
中央絶対偏差を計算します。

シンタックス
mad(<数値列>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
summarize(売上の中央絶対偏差= mad(売上))
各グループの売上の絶対偏差の中央値を計算した新しい列を作成します。

median

概要
中央値を計算します。

シンタックス
median(<数値列>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
summarize(売上の中央値= median(売上))
各グループの収益の中央値を計算した新しい列を作成します。

predict

概要
予測値や残差などのモデルの性能評価や診断に役立つ情報を返します。

シンタックス
predict(<モデル列>, data = <データセット列>, newdata = <データセット>, type.predict = "link"|"response")

引数 * data (オプショナル) - モデルの元データを含むデータフレーム名または列を指定します。 * newdata (オプショナル) - 予測を行う新しいデータセットを指定します。 * type.predict (オプショナル) - 予測値のスケールを指定します。 * "link" - 線形予測子のスケール（例：β0+β1*x）で返します。 * "response" - 応答変数のスケールで返します。モデルがglm関数によるロジスティック回帰の場合、"response"は分類のための値を返します。

返り値 Data Frame

例

predict(model) # モデル列がlm のモデルであることを想定 以下のデータフレームを返します

.rownames ARR_DELAY DEP_DELAY .fitted .se.fit .resid .hat .sigma .cooksd .std.resid
1 -15 -9 -13.934 0.0247 -1.066 0.0000035503 13.0886 7.8503e-9 -0.0814
2 -28 -19 -22.4116 0.035 -5.5884 0.0000071333 13.0886 4.3348e-7 -0.427

表には以下の情報が含まれます。

quantile

概要

与えられた確率に対応する標本の分位数を計算します。最小値は確率0に対応し，最大値は確率1に対応します。

シンタックス
quantile(<数値列>, probs = <確率>, na.rm = <TRUE|FALSE>, [type = 1|2|3|4|5|6|7|8|9])

引数

返り値
Numeric

例
//x <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
quantile(x, 0.25)
3.25を返します
quantile(x, .5)
5.5を返します。

sd

概要
標準偏差を計算します。

シンタックス
sd(<数値列>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
summarize(sd = sd(売上))
各グループの収益の標準偏差を計算した新しい列を作成します。

var

概要
分散を計算します。

シンタックス
var(<数値列>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
summarize(売上の分散 = var(売上))
各グループの売上の分散を計算した新しい列を作成します。

stri_compare

概要
2つの文字列を比較し、辞書順で前後関係を判定します。結果は-1(先に位置する)、0(等しい)、1(後に位置する)の数値で返されます。

シンタックス
stri_compare(<テキストの列1>, <テキストの列2>, ..., opts_collator = NULL)

引数

例
stri_compare(X1, Y1) X1列とY1列の文字列を辞書順で比較し、X1の方が前なら-1、同じなら0、後ろなら1を返します。

X1 Y1 NEW
apple banana -1
banana banana 0
cat banana 1

stri_compare(X1, Y1, opts_collator = stri_opts_collator(strength = 2)) 大文字小文字を区別せずに比較します。

X1 Y1 NEW
APPLE apple 0
banana BANANA 0
Cat cat 0

stri_datetime_format

概要
指定された日時のフォーマットにもとづいて日付・時間型の列を文字列に変換します。

シンタックス
stri_datetime_format(<日付・時間型の列>, format = <フォーマット>, tz = <タイムゾーン>, locale = <ロケール>)

引数

例
stri_datetime_format(X1, format="MM/dd/uuuu") X1列(日付・時間型)の値を月/日/年のフォーマットで文字列に変換します。

X1 NEW
2024-01-01 09:00:00 01/01/2024
2024-01-02 14:30:00 01/02/2024
2024-01-03 18:15:00 01/03/2024

stri_escape_unicode

概要
文字列の中の非ASCII文字（日本語などの多バイト文字や特殊記号）をUnicodeエスケープシーケンス（\uXXXX形式）に変換します。ASCII文字（英数字や基本的な記号）はそのまま保持されます。

シンタックス
stri_escape_unicode(<文字列列>)

引数

返り値
Character

例
stri_escape_unicode(X1) X1列の文字列をASCIIエスケープシーケンスに変換します。

X1 NEW
Hello Hello
日本語 \u65E5\u672C\u8A9E
♥ \u2665

stri_numbytes

概要
テキストデータが保存に必要なバイト数を返します。UTF-8エンコードでは、1文字が1-4バイトで表現されるため、文字数とバイト数は異なる場合があります。

シンタックス
stri_numbytes(<文字列>)

引数

例 stri_numbytes(X1) X1列の文字列について、保存に必要なバイト数を返します。

X1 NEW
hello 5
こんにちは 15
123 3

stri_rand_strings

概要
指定された長さのランダムな文字列を生成します。ASCII文字やUnicode文字など様々な文字種を使って生成できます。

シンタックス
stri_rand_strings(n = <生成する文字列数>, length = <各文字列の長さ>, pattern = <文字パターン>)

引数

例 stri_rand_strings(X1, length=5, pattern="[A-Z]") X1列の数値を元に、指定された長さ(5文字)の大文字のみのランダム文字列を生成します。

X1 NEW
1 KXMPQ
2 RNWVY
3 LBFTH

stri_rand_strings(X1, length=8, pattern="[0-9]") X1列の数値を元に、指定された長さ(8文字)の数字のみのランダム文字列を生成します。

X1 NEW
1 47295836
2 91634507
3 25803914

stri_rand_strings(X1, length=6, pattern="[A-Za-z0-9]") X1列の数値を元に、指定された長さ(6文字)の英数字のランダム文字列を生成します。

X1 NEW
1 kR9nP2
2 mX4vL8
3 tB7hJ5

str_c

概要
複数のテキストや列をくっつけることができます。

シンタックス
str_c(<列>, sep = <区切り文字>, collapse = <区切り文字>)

引数

返り値
Character

例 str_c(FirstName, LastName) FirstName列とLastName列をくっつけます。

FirstName LastName NEW
Smith John SmithJohn
Jones Mike JonesMike
Brown Lisa BrownLisa

str_c(FirstName, LastName, sep = " ") FirstName列とLastName列を半角スペースで区切ってくっつけます。

X1 Y1 NEW
Last First Last-First
Smith John Smith-John
Brown Mike Brown-Mike

str_c(X1, collapse = ",") X1列の値をカンマで区切って1つの文字列をもとに、該当するすべてのテキストを一つのテキストとして値を返します。主に集計の中で使用します。

X1 NEW
Apple Apple,Banana,Orange
Banana Apple,Banana,Orange
Orange Apple,Banana,Orange

str_conv

概要
テキストを指定されたエンコーディング（例：UTF-8）に変換します。

シンタックス
str_conv(<テキストの列>, <encoding>)

引数

返り値
Character

例
str_conv(X1, "UTF-8") X1列の文字エンコーディングを変換します。

X1 NEW
データ データ
分析 分析
テスト テスト

str_conv("Exploratory", "UTF-8")

str_count

概要
テキストデータの文字数または単語数を返します。一致したパターンまたはテキストのみをカウントするように設定できます。

シンタックス
str_count(<列名>, pattern = <文字列>)
str_count(<列名>, pattern = [<正規表現>])
str_count(<列名>, pattern = [boundary("word")])

引数

返り値
Numeric

例 str_count(X1) X1列の全文字数をカウントします。

X1 NEW
I'm traveling to New York. 26
Hello World! 12
R Programming 13

str_count(X1, "New") X1列の"New"の出現回数をカウントします。

X1 NEW
New York New Jersey 2
New Mexico 1
Old City 0

str_count(X1, "[:alpha:]") X1列のアルファベットの数をカウントします。

X1 NEW
ABC123def 6
Hello123 5
R2D2 3

str_count(X1, "[:digit:]") X1列の数字の数をカウントします。_

X1 NEW
ABC123 3
R2D2 2
Hello 0

str_count(X1, boundary("word")) X1列の単語数をカウントします。

X1 NEW
I am traveling 3
Hello World 2
Programming 1

str_count(X1, ".") X1列の全ての文字をカウントします（ピリオドは何でもマッチします）。

X1 NEW
ABC 123 7
Hello! 6
R&D 3

str_count(X1, fixed(".")) X1列の文字としてのピリオドの数をカウントします。

X1 NEW
www.example.com 2
Hello. World. 2
No dots 0

str_detect

概要
特定の文字列が含まれているかどうかに基づいて、TRUEまたはFALSEを返します。

シンタックス
str_detect(<テキストの列>, <文字列または正規表現>)

引数

返り値
Logical

例 str_detect(X1, "New") X1列の文字列に"New"が含まれているかを論理値（TRUE、FALSE）で返します。

X1 NEW
Seattle FALSE
New York TRUE
Newark TRUE

str_detect(X1, "[:alpha:]") X1列の文字列にアルファベットが含まれているかを論理値（TRUE、FALSE）で返します。

X1 NEW
123 FALSE
abc123 TRUE
ABC TRUE

str_detect(X1, "[:digit:]") X1列の文字列に数字が含まれているかを論理値（TRUE、FALSE）で返します。

X1 NEW
abc FALSE
123 TRUE
abc123 TRUE

str_detect(X1, "^New") X1列の文字列が"New"で始まるかを論理値（TRUE、FALSE）で返します。

X1 NEW
Old York FALSE
New York TRUE
Newark TRUE

str_detect(X1, "New$") X1列の文字列が"New"で終わるかをどうかを論理値（TRUE、FALSE）で返します。

X1 NEW
New York FALSE
Something New TRUE
Brand New TRUE

str_detect(X1, c("New", "Old")) X1列の文字列に"New"または"Old"が含まれているかを論理値（TRUE、FALSE）で返します。

X1 NEW
Tokyo FALSE
New York TRUE
Old Town TRUE

str_dup

概要
文字列の値を繰り返します。

シンタックス
str_dup(<テキストの列>, times = <繰り返す回数>)

引数

返り値
Character

例
str_dup(X1, times = 2) X1列の文字列を指定回数繰り返します。

X1 NEW
abc abcabc
wow wowwow
hey heyhey

str_extract

概要
指定した文字列または正規表現に一致する文字列を抽出します。

シンタックス
str_extract(<テキストの列>, <抽出する文字列>)

引数

返り値
Character

例 str_extract(X1, "[A-Za-z]+") X1列から最初のアルファベットの連続を抽出します。

X1 NEW
ABC123 ABC
123DEF DEF
A1B2C3 A

str_extract(X1, "[:alpha:]+") X1列から連続するアルファベットの連続を抽出します。

X1 NEW
ABC123 ABC
123DEF DEF
A1B2C3 A

str_extract(X1, "[0-9]+") X1列から数字の連続を抽出します。

X1 NEW
ABC123 123
456DEF 456
A1B2C3 1

str_extract(X1, "[:digit:]+") X1列から数字の連続を抽出します。

X1 NEW
ABC123 123
456DEF 456
A1B2C3 1

str_extract_all

概要
指定した文字列または正規表現に一致する文字列をすべて抽出します。

シンタックス
str_extract_all(<テキストの列>, <抽出する文字列>)

引数

返り値
List

例 str_extract_all(X1, "[:alpha:]+") X1列から全てのアルファベットの連続を抽出します。

X1 NEW
Hello world Hello, world
ABC123DEF ABC, DEF
R2D2C3PO R, D, C, PO

list_to_text(str_extract_all(X1, "[a-zA-Z]+")) X1列からアルファベットのみを抽出し、それらを結合したテキストに変換します。

X1 NEW
Hello123World Hello, World
R2D2C3PO R, D , C , PO
Data_Science_2023 Data, Science

list_to_text(str_extract_all(X1, "[a-zA-Z0-9]+")) X1列からアルファベットと数字を抽出し、それらを結合したテキストに変換します。

X1 NEW
Hello_123_World! Hello,123,World
R2D2_C3PO R2D2,C3PO
Data-Science-2023 Data,Science,2023

list_to_text(str_extract_all(X1, "[:alnum:]+")) X1の列から全ての文字と数字を抽出します。

X1 NEW
Hello_123_World! Hello, 123, World
東京-Tokyo-2023 東京, Tokyo, 2023
Data@Science#2023 Data, Science, 2023

str_length

概要
テキストデータの文字数を返します。

シンタックス
str_length(<列名>)

返り値
Numeric

例
str_length(X1) X1列の文字列の長さを返します。

X1 NEW
Hello 5
World 5
R 1

str_pad

概要

指定した文字数に満たない空白箇所をスペース、または特定の文字で埋めることができます。

シンタックス
str_pad(<テキストの列>, width = <数値>, side = "left"|"right"|"both", pad = <埋める文字>)

引数

返り値
Character

例 str_pad(X1, 5, pad = "0", side = "left") X1列の文字列を5桁に満たない場合、5桁になるように左から0で埋めます。

X1 NEW
1 00001
42 00042
12345 12345

str_replace

概要
指定した文字列または正規表現に一致する文字列を置き換えます。

シンタックス
str_replace(<テキストの列>, <置換元の文字列>, <置換後の文字列>)

引数

返り値
Character

例
str_replace(X1, "York", "Jersey") X1列の"York"を"Jersey"に置換します。

X1 NEW
I am traveling to New York!! I am traveling to New Jersey!!
Old York Old Jersey
Yorkshire Jerseyshire

str_replace(X1, "^New", "Old") X1列の先頭の"New"を"Old"に置換します。

X1 NEW
New York New Old York New
New Town Old Town
Newport Oldport

str_replace(X1, "New$", "Old") X1列の末尾の"New"を"Old"に置換します。

X1 NEW
New York New New York Old
Brand New Brand Old
New Town New Town

str_replace_all

概要
指定した文字列または正規表現に一致する文字列をすべて置き換えます。

シンタックス
str_replace_all(<テキストの列>, <置換元の文字列>, <置換後の文字列>)

引数

返り値
Character

例
str_replace_all(X1, "Corp.", "Corporation") X1列の全ての"Corp."を"Corporation"に置換します。

X1 NEW
Softbank Corp., Airbnb Corp. Softbank Corporation, Airbnb Corporation
Apple Corp. Apple Corporation
Microsoft Corp. Microsoft Corporation

str_replace_na

概要
欠損値（NA）を特定の文字列に置換します。

シンタックス
str_replace_na(<テキストの列>, <置換する文字列>)

引数

返り値
Character

例 str_replace_na(X1, "Not Available") X1列の欠損値(NA)を"Not Available"に置換します。

X1 NEW
NA Not Available
Data Data
NA Not Available

str_split

概要
指定した区切り文字によって、複数のテキストに分割します。値はリストとして返されるため、unnest() 関数で新しく作成された列のネストを解除する必要があります。

シンタックス
str_split(<テキストの列>, pattern = <文字列または正規表現>, n = <数値>)

引数

返り値
List

例
str_split(X1, ",") X1列の文字列をカンマで分割してリストを生成します。

X1 NEW
a, b, c c("a", " b", " c")
d, e c("d", " e")
f, g, h c("f", " g", " h")

str_sub

概要
位置に基づいて文字列を抽出します。

シンタックス
str_sub(<テキストの列>, <開始位置>, <終了位置>)

引数

返り値
Character

例 str_sub(X1, start = 7, end = 12) X1列の7文字目から12文字目を抽出します。

X1 NEW
Kevin Spacey Spacey
Hello World! World
Programming mming

str_sub(X1, start = 7) X1列の7文字目から最後までを抽出します。

X1 NEW
Kevin Spacey Spacey
Programming mming

str_sub(X1, start = -6) X1列の末尾から6文字を抽出します。

X1 NEW
Kevin Spacey Spacey
Code Code
Programming mming

str_to_lower

概要
テキストを小文字に変換します。

シンタックス
str_to_lower(<テキストの列>, locale = <ロケール>)

引数

返り値
Character

例
str_to_lower(X1) X1列を小文字に変換します。

X1 NEW
CALIFORNIA california
Data Analysis data analysis
R&D r&d

str_to_title

概要
テキストをタイトルケースに変換します。

シンタックス
str_to_title(<テキストの列>, locale = <ロケール>)

引数

返り値
Character

例
str_to_title(X1) X1列の各単語の先頭を大文字に変換します。

X1 NEW
CALIFORNIA California
data analysis Data Analysis
r programming R Programming

str_to_upper

概要
テキストを大文字に変換します。

シンタックス
str_to_upper(<テキストの列>, locale = <ロケール>)

引数

返り値
Character

例
str_to_upper(X1) X1列を大文字に変換します。

X1 NEW
california CALIFORNIA
Data Analysis DATA ANALYSIS
R&D R&D

str_to_upper(X1, locale = "en") X1列を英語ロケールで大文字に変換します。

X1 NEW
i I
data DATA
r&d R&D

str_trim

概要
テキストの中にある空白を取り除きます。

シンタックス
str_trim(<テキストの列>, side = "both"|"left"|"right")

引数

返り値
Character

例 str_trim(X1) X1列の前後の空白、タブ文字、改行文字などを削除します。

X1 NEW
String with trailing and leading white space   String with trailing and leading white space
   Another string with spaces   Another string with spaces
 One more example  One more example

word

概要
テキストデータの最初、最後、またはN番目の単語を抽出します。

シンタックス
word(<テキストの列>, start = <数値>, end = <数値>, sep = <区切り文字>)

引数

返り値
Character

例
word(X1, 1) X1列から1番目の単語を抽出します。

X1 NEW
I am traveling I
Hello World Hello
Data Analysis Data

word(X1, 1, 3) X1列から1-3番目の単語を抽出します。

X1 NEW
I am traveling to I am traveling
This is good This is good
A B C D A B C

word(X1, -1) X1列から最後の単語を抽出します。

X1 NEW
I am traveling traveling
Hello World World
Data Analysis Analysis

word(X1, -2, -1) X1列から最後から2番目と最後の単語を抽出します。

X1 NEW
I am traveling am traveling
Hello World Hello World
Big Data Analysis Data Analysis

word(X1, 1, sep = "-") X1列からハイフン区切りで1番目の単語を抽出します。

complete

概要
欠損しているデータの組み合わせを追加したデータフレームを返します。

シンタックス
complete(<列>, fill = <リスト>)

引数

合わせて使われることが多い関数
full_seq, nesting

例

サンプルデータ:

年 商品名 タイプ 売上
2013 iPhone 5 100
2013 iPad mini 50
2015 iPhone 6 200

complete(年, 商品)
年と商品の値の全ての組み合わせを返します。

年 商品名 タイプ 売上
2013 iPad mini 50
2013 iPhone 5 100
2015 iPad NA NA
2015 iPhone 6 200

complete(年, 商品, fill = list(売上 = 0))
年と商品の値の全ての組み合わせを返したうえで、NAを0で埋めます。

年 商品名 タイプ 売上
2013 iPad mini 50
2013 iPhone 5 100
2015 iPad NA 0
2015 iPhone 6 200

complete(年= full_seq(年, period = 1), 商品名) _年と商品の値の全ての組み合わせを返したうえで、掛けている年(2014年)を埋めます。

年 商品名 タイプ 売上
2013 iPad mini 50
2013 iPhone 5 100
2014 iPad NA NA
2014 iPhone NA NA
2015 iPad NA NA
2015 iPhone 6 200

complete(年, 商品名, タイプ)
年、商品、タイプの値の全ての組み合わせを返します。

年 商品名 タイプ 売上
2013 iPad 5 NA
2013 iPad 6 NA
2013 iPad mini 50
2013 iPhone 5 100
2013 iPhone 6 NA
2013 iPhone mini NA
2015 iPad 5 NA
2015 iPad 6 NA
2015 iPad mini NA
2015 iPhone 5 NA
2015 iPhone 6 200
2015 iPhone mini NA

complete(年, nesting(商品名, タイプ))
nesting()関数を使うことで、指定した列のデータに実際に存在する値の組み合わせを追加できます。

年 商品名 タイプ 売上
2013 iPad mini 50
2013 iPhone 5 100
2013 iPhone 6 NA
2015 iPad mini NA
2015 iPhone 5 NA
2015 iPhone 6 200

expand

概要
指定した列のすべての組み合わせを追加して、データフレームを拡張します。

シンタックス
expand(<列>)

引数

合わせて使われることが多い関数
full_seq, nesting

例

サンプルデータ:

年 商品名 タイプ 売上
2013 iPhone 5 100
2013 iPad mini 50
2015 iPhone 6 200

expand(年, 商品名) 年と商品名の値のすべての組み合わせを返します。

年 商品名
2013 iPad
2013 iPhone
2015 iPad
2015 iPhone

expand(年 = full_seq(年, period = 1), 商品名) 年と商品名の値のすべての組み合わせを返し、さらに不足している年(2014年)も埋めます。

年 商品名
2013 iPad
2013 iPhone
2014 iPad
2014 iPhone
2015 iPad
2015 iPhone

expand(年, 商品名, タイプ) 年、商品名、タイプの値のすべての組み合わせを返します。

年 商品名 タイプ
2013 iPad 5
2013 iPad 6
2013 iPad mini
2013 iPhone 5
2013 iPhone 6
2013 iPhone mini
2015 iPad 5
2015 iPad 6
2015 iPad mini
2015 iPhone 5
2015 iPhone 6
2015 iPhone mini

expand(年, nesting(商品名, タイプ)) nesting()関数を使用して、特定の列の値の組み合わせを固定し、それらを他の列の中にネストします。

年 商品名 タイプ
2013 iPad mini
2013 iPhone 5
2013 iPhone 6
2015 iPad mini
2015 iPhone 5
2015 iPhone 6

extract_numeric

概要
指定されたテキストから数字のみを抽出します。数値以外のフォーマットがある文字列（例: $1,200.34, -12%, X1）に便利です。

シンタックス
extract_numeric(<列名>)

返り値
Numeric

例
extract_numeric(X1) X1列から数値のみを抽出します。通貨記号、カンマ、パーセント記号などは除去されます。

X1 NEW
$56,500.00 56500
-45% -45
1,234.56円 1234.56

fill

概要
欠損値（NA）を前の行または後の行の値で埋めます。特に、データが省略されている場合に、同じグループ内で値を補完するのに便利です。

シンタックス
fill(<列名>, .direction = <fill_direction>)

引数

返り値
Data Frame（指定した列の欠損値が補完されたデータ）

例

元データ：

Year POPULATION PRODUCTION UNEMPLOYMENT
2000 10,000 500 5.0
2001 NA 600 4.8
2002 NA NA 4.6
2003 12,000 700 NA

fill(POPULATION)

前の行の値を使用して、POPULATION列の欠損値を埋める。

Year POPULATION PRODUCTION UNEMPLOYMENT
2000 10,000 500 5.0
2001 10,000 600 4.8
2002 10,000 NA 4.6
2003 12,000 700 NA

fill(POPULATION, .direction = "up")

次の行の値を使用して、POPULATION列の欠損値を埋める。

Year POPULATION PRODUCTION UNEMPLOYMENT
2000 10,000 500 5.0
2001 12,000 600 4.8
2002 12,000 NA 4.6
2003 12,000 700 NA

fill(POPULATION, PRODUCTION)

前の行の値を使用して、POPULATION列とPRODUCTION列の欠損値を埋める。

Year POPULATION PRODUCTION UNEMPLOYMENT
2000 10,000 500 5.0
2001 10,000 600 4.8
2002 10,000 600 4.6
2003 12,000 700 NA

fill(-UNEMPLOYMENT)

UNEMPLOYMENT列以外のすべての列の欠損値を前の行の値で埋める。

Year POPULATION PRODUCTION UNEMPLOYMENT
2000 10,000 500 5.0
2001 10,000 600 4.8
2002 10,000 600 4.6
2003 12,000 700 NA

full_seq

概要
指定した列の値に基づいて数値シーケンスを生成します。

シンタックス
full_seq(<数値列>, period = <数値>)

引数

合わせて使われることが多い関数
complete, expand

例
サンプルデータ:

年 商品名 タイプ 売上
2013 iPhone 5 100
2013 iPad mini 50
2015 iPhone 6 200

expand(年 = full_seq(年, period = 1), 商品名) 年と商品名の値のすべての組み合わせを返し、さらに不足している年(2014年)も埋めます。

年 商品名
2013 iPad
2013 iPhone
2014 iPad
2014 iPhone
2015 iPad
2015 iPhone

full_seq()関数なしの場合:

expand(年, 商品名) 年と商品名の値のすべての組み合わせを返します。

年 商品名
2013 iPad
2013 iPhone
2015 iPad
2015 iPhone

nest

概要
一連の列をリスト列としてネスト（入れ子）化します。

シンタックス
nest(<列> , .key = <テキスト>)

引数

返り値
Data Frame

例
サンプルデータ

年 商品名 タイプ 売上
2013 iPhone 5 100
2013 iPad mini 50
2015 iPhone 6 200

nest(商品名, タイプ, 売上, .key = a) これにより、データフレームのリストである新しい列が作成され、各行のデータフレームには「商品名」、「タイプ」、「売上」の値が含まれます。

年 a
2013 list()
2015 list()

nesting

概要
複数の列を固定して、それらの列に実際に存在する値の組み合わせのみをcomplete()またはexpand()操作で使用するようにします。

シンタックス
nesting(<列>)

引数

合わせて使われることが多い関数
complete, expand

例
サンプルデータ:

年 商品名 タイプ 売上
2013 iPhone 5 100
2013 iPad mini 50
2015 iPhone 6 200

expand(年, nesting(商品名, タイプ)) nesting()関数を使用して、特定の列の値の組み合わせを固定し、それらを他の列の中にネストします。

年 商品名 タイプ
2013 iPad mini
2013 iPhone 5
2013 iPhone 6
2015 iPad mini
2015 iPhone 5
2015 iPhone 6

nesting()なしの場合:

expand(年, 商品名, タイプ) 年、商品名、タイプの値のすべての組み合わせを返します。

年 商品名 タイプ
2013 iPad 5
2013 iPad 6
2013 iPad mini
2013 iPhone 5
2013 iPhone 6
2013 iPhone mini
2015 iPad 5
2015 iPad 6
2015 iPad mini
2015 iPhone 5
2015 iPhone 6
2015 iPhone mini

概要
複数の列を取り、それらをキー・バリューのペアに変換します。その際、他のすべての列は必要に応じて複製されます。

シンタックス
gather(<新しいキー列>, <新しい値列>, <列>, na.rm = <論理値>, convert = <論理値>)

引数

返り値
Data Frame

例
gather(COUNTRY, POPULATION, 2:50, na.rm = FALSE) 2列目から50列目までを、COUNTRYとPOPULATIONという2つの新しい列に変換します。

gather(COUNTRY, POPULATION, -YEAR) YEAR列以外のすべての列を、COUNTRYとPOPULATIONという2つの新しい列に変換します。

gather(COUNTRY, POPULATION, starts_with("country")) 名前が"country"で始まる列を、COUNTRYとPOPULATIONという2つの新しい列に変換します。

separate

概要
区切り文字を含む列を複数の列に分割します。

シンタックス
separate(<テキスト・日付列>, into = c("<新しい列名>"), sep = <テキスト>, remove=<論理値>, convert=<論理値>, extra = "warn"|"drop"|"merge", fill = "warn"|"right"|"left")

引数

返り値
Data Frame

例
separate(NAME, into = c("FIRSTNAME", "LASTNAME"), extra="drop") NAME列を非英数字の値でFIRSTNAMEとLASTNAME列に分割します。余分な部分がある場合は削除されます。

separate(NAME, into = c("FIRSTNAME", "LASTNAME"), remove = FALSE) NAME列を非英数字の値でFIRSTNAMEとLASTNAME列に分割します。NAME列は保持されます。

separate(NAME, into = c("FIRSTNAME", "LASTNAME"), extra="merge") NAME列を非英数字の値でFIRSTNAMEとLASTNAME列に分割します。余分な部分は最後の列に結合されます。

separate(NAME, into = c("FIRSTNAME", "LASTNAME"), sep = "-") NAME列をダッシュ"-"でFIRSTNAMEとLASTNAME列に分割します。

separate(NAME, into = c("FIRSTNAME", "LASTNAME"), sep = 2) NAME列を位置2でFIRSTNAMEとLASTNAMEに分割します。

separate(DATE, into = c("Y", "M", "D"), convert = TRUE) DATE列をYear、Month、Day列に分割し、ヒューリスティックに基づいて各列のデータ型を設定します。

spread

概要
キー・バリューのペアを複数の列に展開します。欠損値はNAで置き換えられます。

シンタックス
spread(<キー列>, <値列>, fill = <値>, convert = <論理値>, drop = <論理値>, sep=<テキスト>)

引数

返り値
Data Frame

例
spread(COUNTRY, POPULATION) COUNTRY-POPULATIONのペアをCOUNTRYの複数の列に展開します。

spread(COUNTRY, POPULATION, fill = "NA") COUNTRY-POPULATIONのペアをCOUNTRYの複数の列に展開し、欠損値を"NA"テキストで埋めます。

unite

概要
複数の列を1つの列に結合します。デフォルトでは、値を"_"で連結し、元の列を削除します。リストで指定された複数の列を一度に結合できます。

シンタックス
unite(<新しい列>, <列>, sep = <テキスト>, remove = <論理値>)

引数

返り値
Data Frame

例
unite(NAME, FIRSTNAME, LASTNAME) FIRSTNAMEとLASTNAMEを_で結合して、NAMEという新しい列を作成します。

unite(NAME, FIRSTNAME, LASTNAME, sep = "-") FIRSTNAMEとLASTNAMEを-で結合して、NAMEという新しい列を作成します。

unnest

概要
リスト列またはデータフレームのリストを展開し、リストの各要素が独自の行に表示されるようにします。

シンタックス
unnest(<リスト列> , .drop = <論理値>, .id = <テキスト>, .sep = <テキスト>)

引数

返り値
Data Frame

例
リスト列を持つサンプルデータ

issue_id assignee
720 list(Kan, Kei)
721 list(Kan, Marie, Simon)

unnest() または unnest(assignee) リストであるassignee列を展開します。これにより、リストの各値に独自の行が与えられます。

issue_id assignee
720 Kan
720 Kei
721 Kan
721 Marie
721 Simon

データフレームのリストを持つサンプルデータ：

issue_id assignee
720 list(name = Kan, id = 105, country = US )
721 list(name = Kei, id = 106, country = Japan )

unnest() データフレームのリストであるassignee列を展開します。これにより、ネストされたデータフレームの各列の列が作成されます。

issue_id name id country
720 Kan 105 US
721 Kei 106 Japan

unnest(.sep="-") .sep引数を使用すると、結果の列は元のリスト列名と.sep引数で接続されます。

issue_id assignee-name assignee-id assignee-country
720 Kan 105 US
721 Kei 106 Japan

2つのリスト列を持つサンプルデータ

issue_id assignee category
720 list(Kan, Kei) list(Critical, Security)
721 list(Kan, Marie, Simon) list(Critical, Minor Issue)

unnest(assignee, .drop = FALSE) リストであるassignee列を展開します。これにより、リストの各値に独自の行が与えられます。

issue_id assignee category
720 Kan list(Critical, Security)
720 Kei list(Critical, Security)
721 Kan list(Critical, Security)
721 Marie list(Critical, Minor Issue)
721 Simon list(Critical, Minor Issue)

param_remove

概要
指定したURLからパラメータを削除します。

シンタックス
param_remove(<テキストの列>, keys = <文字列>)

引数

返り値
Character

例
param_remove(X1, keys = c("q","ticket")) X1列のURLから、指定したたパラメーター（この場合は"q"と"ticket"）を削除します。

X1 NEW
https://example.com/issues?q=is%3Aopen&ticket=open https://github.com/issues
https://example.com/search?q=test&ticket=123&other=value https://example.com/search?other=value
https://site.com/page?ticket=open&q=search&id=1 https://site.com/page?id=1

url_decode

概要
指定したURLをデコードします。 文字コードはUTF-8を前提としています。

シンタックス
url_decode(<テキストの列>)

引数

返り値
Character

例
url_decode(X1) X1列のURLエンコードされた文字列をデコードします。

X1 NEW
http://exploratory.io%3fname%3dflight%20data%20analysis%20%28V1%29 http://exploratory.io?name=flight data analysis (V1)
http://example.com%3Fquery%3Dtest%20case http://example.com?query=test case
http://site.com%2Fpath%20with%20space http://site.com/path with space

url_encode

概要
指定したURLをエンコードします。 文字コードはUTF-8を前提としています。

シンタックス
url_encode(<テキストの列>)

引数

返り値
Character

例
url_encode(X1) X1列のURLをUTF-8にエンコードします。

X1 NEW
http://exploratory.io?name=flight data analysis (V1) http://exploratory.io%3fname%3dflight%20data%20analysis%20%28V1%29
http://example.com/path with space http://example.com/path%20with%20space
http://site.com?query=test case http://site.com%3Fquery%3Dtest%20case

url_parameters

概要
url からデコードされたクエリのパラメーターを返します。

シンタックス
url_parameters(<テキストの列>)

引数

返り値
Character

例
url_parameters(X1) X1列のURLからパラメータ部分を抽出します。

X1 NEW
https://exploratory.io/?debug=%3Ctrue%3E#test debug=<true>
https://exploratory.io/?param1=value1&param2=value2 param1=value1&param2=value2
https://exploratory.io/?id=123 id=123

roll_max

概要
移動計算により、指定されたウィンドウサイズ間の最大値を返します。

シンタックス
roll_max(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_max(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の最大値を返します。

year revenue rolling_max
2012 100 0
2013 200 300
2014 300 400
2015 400 500
2016 500 0

roll_max(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の最大値を返します。

year revenue rolling_max
2012 100 300
2013 200 400
2014 300 500
2015 400 0
2016 500 0

roll_mean

概要
移動計算により、指定されたウィンドウサイズ間の平均値を返します。

シンタックス
roll_mean(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_mean(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の平均値を返します。

year revenue rolling_mean
2012 100 0
2013 200 200
2014 300 300
2015 400 400
2016 500 0

roll_mean(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の平均値を返します。

year revenue rolling_mean
2012 100 200
2013 200 300
2014 300 400
2015 400 0
2016 500 0

roll_median

概要
移動計算により、指定されたウィンドウサイズ間の中央値を返します。

シンタックス
roll_median(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_median(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の中央値を返します。

year revenue rolling_median
2012 100 0
2013 200 200
2014 300 300
2015 400 400
2016 500 0

roll_median(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の中央値を返します。

year revenue rolling_median
2012 100 200
2013 200 300
2014 300 400
2015 400 0
2016 500 0

roll_min

概要
移動計算により、指定されたウィンドウサイズ間の最小値を返します。

シンタックス
roll_min(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_min(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の最小値を返します。

year revenue rolling_min
2012 100 0
2013 200 100
2014 300 200
2015 400 300
2016 500 0

roll_min(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の最小値を返します。

year revenue rolling_min
2012 100 100
2013 200 200
2014 300 300
2015 400 0
2016 500 0

roll_prod

概要
移動計算により、指定されたウィンドウサイズ間の積値を返します。

シンタックス
roll_prod(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_prod(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の積値を返します。

year revenue rolling_prod
2012 1 0
2013 2 6
2014 3 24
2015 4 60
2016 5 0

roll_prod(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の積値を返します。

year revenue rolling_prod
2012 1 6
2013 2 24
2014 3 60
2015 4 0
2016 5 0

roll_sd

概要
移動計算により、指定されたウィンドウサイズ間の標準偏差を返します。

シンタックス
roll_sd(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_sd(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の標準偏差を返します。

year revenue rolling_sd
2012 100 0
2013 200 100
2014 300 100
2015 400 100
2016 500 0

roll_sd(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の標準偏差を返します。

year revenue rolling_sd
2012 100 100
2013 200 100
2014 300 100
2015 400 0
2016 500 0

roll_sum

概要
移動計算により、指定されたウィンドウサイズ間の合計値を返します。

シンタックス
roll_sum(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_sum(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の合計値を返します。

year revenue rolling_sum
2012 100 0
2013 200 600
2014 300 900
2015 400 1200
2016 500 0

roll_sum(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の合計値を返します。

year revenue rolling_sum
2012 100 600
2013 200 900
2014 300 1200
2015 400 0
2016 500 0

roll_var

概要
移動計算により、指定されたウィンドウサイズ間の分散を返します。

シンタックス
roll_var(<数値列>, n = <数値>, weights = NULL, by = <数値>, fill = <数値>, align = <left | center | right>, normalize = <TRUE|FALSE>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
roll_var(revenue, n = 3, align="center", fill = 0)
NAを0に設定し、前と次の値から始まる3つの値の分散を返します。

year revenue rolling_var
2012 100 0
2013 200 10000
2014 300 10000
2015 400 10000
2016 500 0

roll_var(revenue, n = 3, align="left", fill = 0)
NAを0に設定し、その値と次の2つ値を含めて、3つの値の分散を返します。

year revenue rolling_var
2012 100 10000
2013 200 10000
2014 300 10000
2015 400 0
2016 500 0

-

概要
Removes column(s). It can be used along with any column(s) selection operation like select(), gather(), etc.

シンタックス
-<列名>

返り値

例
select(-Country)
Remove Country column.
select(-starts_with("user"))
Remove all the columns whose names start with "user".
gather(Year, Population, -Country)
Gather all the columns except Country column into Year and Population columns.

select_if

条件に基づいて列を選択します。例えば、数値型の列だけを選択したり、特定の条件を満たす列だけを選択したりできます。

シンタックス
select_if(<条件>, ...)

引数 * 条件 - TRUEまたはFALSEを返す関数や条件を指定します。TRUEを返す列が選択されます。

例

元のデータ:

ID 名前 年齢 身長 性別 得点
1 田中 30 175 男性 85
2 鈴木 25 160 女性 92
3 佐藤 40 180 男性 78

select_if(is.numeric) 数値型の列だけを選択します。

ID 年齢 身長 得点
1 30 175 85
2 25 160 92
3 40 180 78

元のデータ: select_if(is.character) 文字列型の列だけを選択します。

名前 性別
田中 男性
鈴木 女性
佐藤 男性

select_if(function(x) is.numeric(x) && mean(x) > 100) 数値型かつ平均値が100より大きい列だけを選択します。

身長
175
160
180

starts_with

概要
指定したテキストで始まる列名の列を返します。select()、mutate_at()、summarize_at()などの関数と組み合わせて使用します。

シンタックス
starts_with(<文字列>, ignore.case = <論理値>)

引数 * 文字列 - 検索する列名の接頭辞を指定します * ignore.case - 大文字小文字を区別するかどうかを指定します。デフォルトはTRUEです。

例

元のデータ:

item_id item_name item_price category stock
A001 りんご 100 果物 200
B002 バナナ 150 果物 150
C003 キャベツ 120 野菜 300

select(starts_with("item")) 「item」で始まる列名の列だけを選択します。

item_id item_name item_price
A001 りんご 100
B002 バナナ 150
C003 キャベツ 120

元のデータ:

売上_東京 売上_大阪 売上_名古屋 利益_東京 利益_大阪 利益_名古屋
100 80 90 30 24 27
150 120 110 45 36 33
120 100 80 36 30 24

summarize_at(vars(starts_with("売上")), mean) 「売上」で始まる列の平均値を計算します。

売上_東京 売上_大阪 売上_名古屋
123.3 100 93.3

元のデータ:

Prod_ID Prod_Name Sales_2020 Sales_2021 Sales_2022
A001 りんご 100 110 120
B002 バナナ 150 160 170
C003 キャベツ 120 130 140

select(Prod_ID, Prod_Name, starts_with("Sales")) 「Prod_ID」と「Prod_Name」列、および「Sales」で始まるすべての列を選択します。

Prod_ID Prod_Name Sales_2020 Sales_2021 Sales_2022
A001 りんご 100 110 120
B002 バナナ 150 160 170
C003 キャベツ 120 130 140

ends_with

概要
指定したテキストで終わる列名の列を返します。select()、mutate_at()、summarize_at()などの関数と組み合わせて使用します。

シンタックス
ends_with(<文字列>, ignore.case = <論理値>)

引数 * 文字列 - 検索する列名の接尾辞を指定します * ignore.case - 大文字小文字を区別するかどうかを指定します。デフォルトはTRUEです。

例

元のデータ:

商品ID 商品名 売上_東京 売上_大阪 売上_名古屋 利益_東京 利益_大阪 利益_名古屋
A001 りんご 100 80 90 30 24 27
B002 バナナ 150 120 110 45 36 33
C003 キャベツ 120 100 80 36 30 24

select(商品ID, 商品名, ends_with("東京")) 「商品ID」と「商品名」列、および「東京」で終わるすべての列を選択します。

商品ID 商品名 売上_東京 利益_東京
A001 りんご 100 30
B002 バナナ 150 45
C003 キャベツ 120 36

summarize_at(vars(ends_with("大阪")), mean) 「大阪」で終わる列の平均値を計算します。

売上_大阪 利益_大阪
100 30

元のデータ:

商品ID 商品名 売上高 売上個数 利益額
A001 りんご 100 10 30
B002 バナナ 150 15 45
C003 キャベツ 120 12 36

select(ends_with("高")) 「高」で終わる列名の列だけを選択します。

売上高
100
150
120

contains

概要
指定したテキストを含む列名の列を返します。select()、mutate_at()、summarize_at()などの関数と組み合わせて使用します。

シンタックス
contains(<文字列>, ignore.case = <論理値>)

引数 * 文字列 - 検索する列名に含まれるテキストを指定します * ignore.case - 大文字小文字を区別するかどうかを指定します。デフォルトはTRUEです。

例

元のデータ:

商品ID 商品名 売上_東京 売上_大阪 売上_名古屋 利益_東京 利益_大阪 利益_名古屋
A001 りんご 100 80 90 30 24 27
B002 バナナ 150 120 110 45 36 33
C003 キャベツ 120 100 80 36 30 24

select(contains("売上")) 「売上」を含む列名の列だけを選択します。

売上_東京 売上_大阪 売上_名古屋
100 80 90
150 120 110
120 100 80

mutate_at(vars(contains("大阪")), funs(. * 1.2)) 「大阪」を含む列名の列の値を1.2倍にします。

商品ID 商品名 売上_東京 売上_大阪 売上_名古屋 利益_東京 利益_大阪 利益_名古屋
A001 りんご 100 96 90 30 28.8 27
B002 バナナ 150 144 110 45 43.2 33
C003 キャベツ 120 120 80 36 36 24

元のデータ:

product_id product_name category_id category_name price
A001 りんご CT01 果物 100
B002 バナナ CT01 果物 150
C003 キャベツ CT02 野菜 120

select(contains("name")) 「name」を含む列名の列だけを選択します。

product_name category_name
りんご 果物
バナナ 果物
キャベツ 野菜

matches

概要
正規表現のパターンに一致する列名の列を返します。

シンタックス
matches(<文字列>, ignore.case = <論理値>)

引数 * 文字列 - 検索する正規表現パターンを指定します * ignore.case - 大文字小文字を区別するかどうかを指定します。デフォルトはTRUEです。

例

元のデータ:

user_id user_name item1_price item2_price item3_price item1_qty item2_qty item3_qty
U001 田中 100 150 200 2 1 3
U002 鈴木 120 180 220 1 2 2
U003 佐藤 90 130 180 3 1 1

select(matches("[:digit:]+")) 数字を含む列名の列を選択します。

item1_price item2_price item3_price item1_qty item2_qty item3_qty
100 150 200 2 1 3
120 180 220 1 2 2
90 130 180 3 1 1

select(matches("item[0-9]_price")) 「item」の後に数字、その後に「_price」が続く列名の列を選択します。

item1_price item2_price item3_price
100 150 200
120 180 220
90 130 180

num_range

概要
指定したテキストに続く数値が指定した範囲内にある列名の列を返します。X1、X2、X3、X4などの連番の列名がある場合に特に便利です。

シンタックス
num_range(<文字列>, <開始数値>：<終了数値>)

引数 * 文字列 - 選択する列名の接頭辞を指定します * 開始数値:終了数値 - 列名の接頭辞の後に続く数値の範囲を指定します

例

元のデータ:

ID Name X1 X2 X3 X4 X5 Y1 Y2
1 田中 10 20 30 40 50 100 200
2 鈴木 15 25 35 45 55 150 250
3 佐藤 12 22 32 42 52 120 220

select(num_range("X", 1:3)) 「X1」から「X3」までの列を選択します。

X1 X2 X3
10 20 30
15 25 35
12 22 32

select(ID, Name, num_range("X", 2:4)) 「ID」と「Name」列、および「X2」から「X4」までの列を選択します。

ID Name X2 X3 X4
1 田中 20 30 40
2 鈴木 25 35 45
3 佐藤 22 32 42

any_of

概要
指定した名前のいずれかに一致する列名の列を返します。存在しない列名を指定しても、エラーにはなりません。

シンタックス
any_of(<文字列1>, <文字列2>, ...)

引数 * 文字列1, 文字列2, ... - 選択したい列名のリストを指定します

例

元のデータ:

ID Name Age Gender City Salary
1 田中 30 男性 東京 400000
2 鈴木 25 女性 大阪 350000
3 佐藤 40 男性 名古屋 450000

select(any_of("ID", "Name", "Age")) 「ID」、「Name」、「Age」列を選択します。

ID Name Age
1 田中 30
2 鈴木 25
3 佐藤 40

select(any_of("ID", "Name", "Address")) 「ID」と「Name」列を選択します。「Address」列は存在しないため無視されますが、エラーにはなりません。

ID Name
1 田中
2 鈴木
3 佐藤

元のデータ:

customer_id customer_name order_date order_amount order_status
C001 田中 2023-01-10 5000 完了
C002 鈴木 2023-01-15 3000 処理中
C003 佐藤 2023-01-20 8000 完了

select(any_of("customer_id", "customer_name", "order_amount")) 「customer_id」、「customer_name」、「order_amount」列を選択します。

customer_id customer_name order_amount
C001 田中 5000
C002 鈴木 3000
C003 佐藤 8000

everything

概要
すべての列名を返します。特定の列を最初に配置し、その後にすべての列を配置したい場合に特に便利です。

シンタックス
everything()

引数 なし

例

元のデータ:

ID Name Age Gender City Salary
1 田中 30 男性 東京 400000
2 鈴木 25 女性 大阪 350000
3 佐藤 40 男性 名古屋 450000

select(Name, everything()) 「Name」列を最初に配置し、その後にすべての列を配置します。

Name ID Age Gender City Salary
田中 1 30 男性 東京 400000
鈴木 2 25 女性 大阪 350000
佐藤 3 40 男性 名古屋 450000

select(ID, Name, everything()) 「ID」と「Name」列を最初に配置し、その後にすべての列を配置します。

ID Name Age Gender City Salary
1 田中 30 男性 東京 400000
2 鈴木 25 女性 大阪 350000
3 佐藤 40 男性 名古屋 450000

where

概要
指定した列選択関数（例：is.numeric関数）の戻り値がTRUEとなる列を返します。

シンタックス
where(<列選択関数>)

引数

例
select(where(is.numeric))
全ての数値列を選択します

across

概要
summarize_rowなど、他の関数で使用する列を選択するときに利用する関数です。

シンタックス

引数

例

mutate(Total = summarize_row(across(c(個人からの売上, 法人からの売上, 政府からの売上)), sum, na.rm = TRUE)
各行の指定された列の値を合計し、その合計をTotal列に保存します。

mutate(Total = summarize_row(across(where(is.numeric)), sum, na.rm = TRUE)
各行のすべての数値列の値を合計し、その合計をTotal列に保存します。

rename_with

概要

関数を適用して、複数の列名を一括変換します。

シンタックス

rename_with(.data = <データフレーム名>, .fn = <列名を変換するための関数>, .cols = <変更する列>)

引数

例

従業員データ

年齢 性別 婚姻ｽﾃｰﾀｽ 給料（２０２４） ｽﾄｯｸｵﾌﾟｼｮﾝ
41 女性 独身 5993 0
49 男性 既婚 5130 1
37 男性 独身 2090 0

rename_with(従業員データ, ~ str_normalize(.x)) 従業員データの列名を正規化（標準化）して、列名の全角と半角を統一します。

年齢 性別 婚姻ステータス 給料(2024) ストックオプション
41 女性 独身 5993 0
49 男性 既婚 5130 1
37 男性 独身 2090 0

mutate_all

概要
mutate_all関数は、データフレームのすべての列に対して関数を適用します。すべての列に同じ変換を適用したい場合に便利です。

シンタックス
mutate_all(funs(<関数(s)>), ...)

引数 * .funs - funs()で生成された関数呼び出しのリスト、または関数名の文字ベクトル、あるいは単に関数を指定します

例

元のデータ:

X1 X2 X3
2 4 6
10 20 30
6 8 10

mutate_all(funs(. * 0.5)) すべての列の値に0.5を掛けて、既存の列を上書きします。

X1 X2 X3
1 2 3
5 10 15
3 4 5

元のデータ:

mutate_all(funs(half = . * 0.5)) すべての列の値に0.5を掛けて、新しい列を作成します。新しい列の名前は元の列名に「_half」が追加されます。

X1 X2 X3 X1_half X2_half X3_half
2 4 6 1 2 3
10 20 30 5 10 15
6 8 10 3 4 5

元のデータ:

名前 年齢 得点
田中 30 85
鈴木 25 92
佐藤 40 78

mutate_all(funs(min_rank, dense_rank)) すべての列に対して min_rank と dense_rank 関数を適用し、新しい列を作成します。新しい列の名前は元の列名に関数名が追加されます。

名前 年齢 得点 名前_min_rank 年齢_min_rank 得点_min_rank 名前_dense_rank 年齢_dense_rank 得点_dense_rank
田中 30 85 3 2 2 3 2 2
鈴木 25 92 2 1 3 2 1 3
佐藤 40 78 1 3 1 1 3 1

mutate_at

概要
指定した列に対して関数を適用します。vars()を使用して列を選択し、その列に対して特定の変換を適用できます。

シンタックス
mutate_at(vars(<列名(s)>), funs(<関数(s)>), ...)

引数 * .cols - vars()で生成された列のリスト、または列名の文字ベクトル、または列の位置を示す数値ベクトル * .funs - funs()で生成された関数呼び出しのリスト、または関数名の文字ベクトル、あるいは単に関数

例

元のデータ:

出発遅延 到着遅延 便名 日付
10 5 AB123 2023-01-10
15 20 CD456 2023-01-11
0 -5 EF789 2023-01-12

mutate_at(vars(ends_with("遅延")), funs(min_rank)) 名前が「遅延」で終わる列に対して、min_rank関数を適用します。

出発遅延 到着遅延 便名 日付 出発遅延_min_rank 到着遅延_min_rank
10 5 AB123 2023-01-10 2 2
15 20 CD456 2023-01-11 3 3
0 -5 EF789 2023-01-12 1 1

mutate_at(vars(ends_with("遅延")), funs(. * 0.5)) 名前が「遅延」で終わる列の値に0.5を掛けます。

出発遅延 到着遅延 便名 日付
5 2.5 AB123 2023-01-10
7.5 10 CD456 2023-01-11
0 -2.5 EF789 2023-01-12

mutate_at(c("出発遅延", "到着遅延"), funs(half = . * 0.5)) 「出発遅延」と「到着遅延」列に対して、値に0.5を掛けた新しい列を作成します。

出発遅延 到着遅延 便名 日付 出発遅延_half 到着遅延_half
10 5 AB123 2023-01-10 5 2.5
15 20 CD456 2023-01-11 7.5 10
0 -5 EF789 2023-01-12 0 -2.5

mutate_if

概要
条件に一致する列にのみ関数を適用します。条件はTRUEまたはFALSEを返す関数で指定します。

シンタックス
mutate_if(<条件>, funs(<関数(s)>), ...)

引数 * 条件 - TRUEまたはFALSEを返す述語条件を設定します * .funs - funs()で生成された関数呼び出しのリスト、または関数名の文字ベクトル、あるいは単に関数

例

元のデータ:

名前 年齢 身長 体重 性別
田中 30 175 70 男性
鈴木 25 160 55 女性
佐藤 40 180 75 男性

mutate_if(is.numeric, funs(. * 2)) 数値型の列の値を2倍にします。既存の列を上書きします。

名前 年齢 身長 体重 性別
田中 60 350 140 男性
鈴木 50 320 110 女性
佐藤 80 360 150 男性

mutate_if(is.numeric, funs(double = . * 2)) 数値型の列の値を2倍にした新しい列を作成します。元の列名に「_double」が追加されます。

名前 年齢 身長 体重 性別 年齢_double 身長_double 体重_double
田中 30 175 70 男性 60 350 140
鈴木 25 160 55 女性 50 320 110
佐藤 40 180 75 男性 80 360 150

mutate_if(function(x) is.numeric(x) && mean(x) > 100, funs(scale)) 数値型で、かつ平均値が100より大きい列に対してのみscale関数（標準化）を適用します。

名前 年齢 身長 体重 性別
田中 30 -0.707107 70 男性
鈴木 25 -1.414214 55 女性
佐藤 40 1.414214 75 男性

summarize_all

概要
データフレームのすべての列に対して集計関数を適用します。一般的にgroup_by()と組み合わせて使用し、グループごとのすべての列の統計量を計算します。

シンタックス
summarize_all(funs(<関数(s)>), ...)

引数 * .funs - funs()で生成された関数呼び出しのリスト、または関数名の文字ベクトル、あるいは単に関数

例

元のデータ:

地域 売上 利益 件数
東京 100 30 10
東京 150 45 15
大阪 80 24 8
大阪 120 36 12
名古屋 90 27 9

group_by(地域) %>% summarize_all(mean) 地域ごとにすべての列の平均値を計算します。

地域 売上 利益 件数
東京 125 37.5 12.5
大阪 100 30 10
名古屋 90 27 9

group_by(地域) %>% summarize_all(funs(min, max)) 地域ごとにすべての列の最小値と最大値を計算します。関数名が列名に追加されます。

地域 売上_min 売上_max 利益_min 利益_max 件数_min 件数_max
東京 100 150 30 45 10 15
大阪 80 120 24 36 8 12
名古屋 90 90 27 27 9 9

group_by(地域) %>% summarize_all(funs(average = mean)) 地域ごとにすべての列の平均値を計算します。「average」という接尾辞が各列名に追加されます。

地域 売上_average 利益_average 件数_average
東京 125 37.5 12.5
大阪 100 30 10
名古屋 90 27 9

summarize_at

概要
指定した列に対して集計関数を適用します。特定の列のみに集計操作を行いたい場合に便利です。

シンタックス
summarize_at(vars(<列名(s)>), funs(<関数(s)>), ...)

引数 * .cols - vars()で生成された列のリスト、または列名の文字ベクトル、または列の位置を示す数値ベクトル * .funs - funs()で生成された関数呼び出しのリスト、または関数名の文字ベクトル、あるいは単に関数

例

元のデータ:

地域 売上 利益 商品名 日付
東京 100 30 A商品 2023-01-10
東京 150 45 B商品 2023-01-11
大阪 80 24 A商品 2023-01-10
大阪 120 36 C商品 2023-01-12
名古屋 90 27 B商品 2023-01-11

group_by(地域) %>% summarize_at(vars(売上, 利益), mean) 地域ごとに「売上」と「利益」列の平均値を計算します。

地域 売上 利益
東京 125 37.5
大阪 100 30
名古屋 90 27

group_by(地域) %>% summarize_at(vars(ends_with("上")), funs(平均 = mean, 合計 = sum)) 地域ごとに名前が「上」で終わる列（この場合は「売上」）の平均値と合計値を計算します。

地域 売上_平均 売上_合計
東京 125 250
大阪 100 200
名古屋 90 90

group_by(地域) %>% summarize_at(c(2, 3), mean) 地域ごとに2番目と3番目の列（「売上」と「利益」）の平均値を計算します。

地域 売上 利益
東京 125 37.5
大阪 100 30
名古屋 90 27

summarize_if

概要
summarize_if関数は、条件に一致する列にのみ集計関数を適用します。例えば、数値型の列だけに対して平均値を計算するなどの操作が可能です。

シンタックス
summarize_if(<条件>, funs(<関数(s)>), ...)

引数 * 条件 - TRUEまたはFALSEを返す述語条件を設定します * .funs - funs()で生成された関数呼び出しのリスト、または関数名の文字ベクトル、あるいは単に関数

例

元のデータ:

地域 売上 利益 商品名 日付
東京 100 30 A商品 2023-01-10
東京 150 45 B商品 2023-01-11
大阪 80 24 A商品 2023-01-10
大阪 120 36 C商品 2023-01-12
名古屋 90 27 B商品 2023-01-11

group_by(地域) %>% summarize_if(is.numeric, mean) 地域ごとに数値型の列（この場合は「売上」と「利益」）の平均値を計算します。

地域 売上 利益
東京 125 37.5
大阪 100 30
名古屋 90 27

group_by(地域) %>% summarize_if(is.numeric, funs(平均 = mean, 最大 = max)) 地域ごとに数値型の列の平均値と最大値を計算します。

地域 売上_平均 売上_最大 利益_平均 利益_最大
東京 125 150 37.5 45
大阪 100 120 30 36
名古屋 90 90 27 27

group_by(地域) %>% summarize_if(function(x) is.numeric(x) && mean(x) > 50, mean) 地域ごとに数値型で、かつ平均値が50より大きい列（この場合は「売上」のみ）の平均値を計算します。

地域 売上
東京 125
大阪 100
名古屋 90

vars

概要
ユーザーが選択した列のリストを返します。主にsummarize_at()、mutate_at()、filter_at()などの関数で、特定の列を選択するために使用されます。

シンタックス
vars(<列名(s)>)

引数 * 列名(s) - 選択する列名を指定します。starts_with()、ends_with()、contains()などの関数も使用できます。

例

元のデータ:

地域 売上 利益 顧客数 店舗名
東京 100 30 50 A店
大阪 80 24 40 B店
名古屋 90 27 45 C店

summarize_at(vars(売上, 利益), mean) 「売上」と「利益」列の平均値を計算します。

売上 利益
90 27

group_by(地域) %>% mutate_at(vars(ends_with("上")), funs(ratio = . / sum(.))) 地域ごとに「上」で終わる列（この場合は「売上」）の比率を計算します。

地域 売上 利益 顧客数 店舗名 売上_ratio
東京 100 30 50 A店 1
大阪 80 24 40 B店 1
名古屋 90 27 45 C店 1

if_else

概要 指定した条件を満たすかどうかに応じて、値を返します。

シンタックス
if_else(<条件>, <TRUEのときの戻り値>, <FALSEのときの戻り値>, missing = NULL)

引数

返り値
Vector

例
if_else(X1 >= 500, "高価", "安価")) X1列の値が500以上の場合は"高価"を、そうでない場合は"安価"を返します。

X1 NEW
1000 高価
500 高価
100 安価
50 安価

case_when

概要

複数の条件にもとづいて値を返します。これはSQLのCASE WHENに似ています。条件とそれに対応する値を指定するために両辺の式を使い、ELSE条件としてTRUEを使用することができます。詳しくは以下の例を参照してください。

シンタックス
case_when(...)

引数

返り値 Vector

例
case_when( X1 > 900 ~ "超高額", X1 >= 500 ~ "高額", X1 >= 100 ~ "普通" ) X1列の値に応じて段階的なカテゴリーを返します。条件に合致しない場合はNAとなります。

X1 NEW
1000 超高額
500 高額
100 普通
50 NA

case_when( X1 > 900 ~ "超高額", X1 >= 500 ~ "高額", X1 >= 100 ~ "普通", TRUE ~ "低価格" ) X1列の値に応じて段階的なカテゴリーを返します。どの条件にも合致しない場合は"低価格"となります。

X1 NEW
1000 超高額
500 高額
100 普通
50 低価格

coalesce

概要
欠損値を特定の値または他の列の同じ位置にある値に置き換えます。

シンタックス
coalesce(<欠損値がある列>, <欠損値を埋めたい列1>,<欠損値を埋めたい列2>)

Arguments

返り値
Vector

例
coalesce(X1, 0) X1列の欠損値を0で埋めます。

X1 NEW
1500 1500
NA 0
NA 0
50 50

coalesce(X1, Y1) X1列の欠損値をY1列の値で埋めます。

X1 Y1 NEW
1500 1000 1500
NA 500 500
NA 100 100
50 10 50

na_if

概要
一致する値をNAに置き換えます。

シンタックス

na_if(<列名>, <値>)

引数

返り値 Vector

例
na_if(X1, 999)) X1列の値が999の場合、NAに変換します。

X1 NEW
A A
G G
999 NA

near

概要
2つの数値ベクトルを比較します。浮動小数点数の2つのベクトルが（対で）等しいかどうかを比較する安全な方法です。許容誤差が組み込まれている点におい、== を使うよりも安全です。

シンタックス
near(<数値列>, <数値列>, tol = <数値>)

引数

返り値 Logical

例
near(X1, X2, tol = 0.001) 誤差を0.001まで許容した場合においてX1列とX2列が等しいかどうかを返します。

X1 X2 NEW
0.3 0.3 TRUE
0.30001 0.3 TRUE
0.49 0.5 FALSE

recode

概要

元の値を指定された値で置換します。数値の場合は数値にバックティックをつけるか、その位置に基づいて、置換ができます。文字列の場合は、その名前を置き換えることができます。

シンタックス

recode(<列名>, ..., .default = <文字列>, .missing = <文字列>)

引数

返り値 Vector

例

元のデータが数値の場合: recode(ID, `` ` ``4716`` ` `` = "オラクル", `` ` ``4755`` ` `` = "楽天") | ID | NEW | | ---- | -------- | | 4716 | オラクル | | 4755 | 楽天 | | 2432 | NA |

2432を置換する値の指定がなく、そのデータ型（数値）が他の置換値（文字）とは異なるため、置換値はNAになります。データ型が同じであれば、元の値が利用されます。

recode(ID, `` ` ``4716`` ` `` = "オラクル", `` ` ``4755`` ` `` = "楽天", .default = "不明")
'.default' の引数を使って、デフォルト値を指定できます。

ID NEW
4716 Oracle
4755 Rakuten
2432 不明

元のデータが文字列の場合: recode(ID, "A" = "アップル", "G" = "グーグル")

ID NEW
A Apple
G Google
M M

元の値の'M'には置換値の指定がありませんが、データ型（文字列）が他の置換値（文字列）と同じであるため、元の値を利用することになります。

recode(ID, A = "アップル", G = "グーグル", **.default = "不明") デフォルト値を設定するには、'.default' 引数を使用します。

ID NEW
A アップル
G グーグル
M 不明

recode_factor

概要

元の値を指定された値で置換し、順序付きカテゴリの列を作成します。数値の場合、値にバックティックを付けるか、その位置にもとづいて置き換えることができ、文字列は、その名称をもとに置き換えることができます。

シンタックス

recode_factor(<列名>, ..., .default = <文字列>, .missing = <文字列>, .ordered = <TRUE|FALSE>)

引数

返り値 Factor

例
recode_factor(X1, S = "日曜日", M = "月曜日", T = "火曜日", .ordered = TRUE)) X1列の値を指定した順序付きカテゴリーに変換します。

X1 NEW
M 月曜日（レベル2）
T 火曜日（レベル3）
S 日曜日（レベル1）

separate_rows

概要
区切り文字を含む列を複数の行に分割します。

シンタックス
separate_rows(<テキスト・日付列>, sep = <テキスト>, convert=<論理値>)

引数

返り値
Data Frame

例

元のデータ:

company investors
Uber Lowercase Capital, Benchmark Capital, Google Ventures
Xiaomi Digital Sky Technologies, QiMing Venture Partners, Qualcomm Ventures

separate_rows(investors, sep=", ")

company investors
Uber Lowercase Capital
Uber Benchmark Capital
Uber Google Ventures
Xiaomi Digital Sky Technologies
Xiaomi QiMing Venture Partners
Xiaomi Qualcomm Ventures

unnest_wider

概要
リスト列の各要素を列に変換して展開します。

シンタックス
unnest_wider(col = <リスト列> , names_sep = <テキスト>, names_repair = <テキスト>, simplify = <論理値>, ptype = <リスト>, transform = <リスト>)

引数

返り値
Data Frame

例
unnest_wider(data, col = json_data) JSON形式のデータを含むjson_data列を展開し、各JSONフィールドを独自の列に変換します。

unnest_longer

概要
リスト列の各要素を行に変換して展開します。

シンタックス
unnest_longer(col = <リスト列> , values_to = <テキスト>, indices_to = <テキスト>, indices_include = <論理値>, names_repair = <テキスト>, simplify = <論理値>, ptype = <リスト>, transform = <リスト>)

引数

返り値
Data Frame

例
unnest_longer(data, col = tags) 各行に複数のタグを含むtags列を展開し、各タグを独自の行に表示します。

hoist

概要
リスト列のコンポーネントを選択的に取り出して、トップレベルの列として表示します。

シンタックス
hoist(.col = <リスト列> , .remove = <論理値>, .simplify = <論理値>, .ptype = <リスト>, .transform=<リスト>)

引数

返り値
Data Frame

例
hoist(data, id = "id", name = "user.name", location = "user.location") ネストされたJSONデータから特定のフィールドを抽出し、それらをトップレベルの列として表示します。

drop_na

概要
NA値を持つ行を削除します。

シンタックス
drop_na(<列>,...)
drop_na(-<列>,...)
drop_na(starts_with(<テキスト>, ignore.case = <論理値>))
drop_na(ends_with(<テキスト>, ignore.case = <論理値>))
drop_na(contains(<テキスト>, ignore.case = <論理値>))
drop_na(matches(<テキスト>, ignore.case = <論理値>))
drop_na(num_range(<テキスト>, <開始番号>:<終了番号>))
drop_na(one_of(<テキスト1>, <テキスト2>, ...))
drop_na(<列>, everything())

引数

返り値
Data Frame

例

元のデータ:

location year plant_date harvest_date
Als 1900 NA 35.02899
Als 1901 10.00000 24.02899
Als 1902 12.58863 45.02899
Bea 1900 5.00000 18.00000
Bea 1901 3.31119 10.00000
Bea 1902 29.12891 NA
Bor 1900 12.52136 18.14896
Bor 1901 NA 10.64896
Bor 1902 10.23056 20.64896

drop_na(ends_with("date")) plant_dateとharvest_date列にNA値がない行のみを返します。

location year plant_date harvest_date
Als 1901 10.00000 24.02899
Als 1902 12.58863 45.02899
Bea 1900 5.00000 18.00000
Bea 1901 3.31119 10.00000
Bor 1900 12.52136 18.14896
Bor 1902 10.23056 20.64896

add_row

Summary
Add rows with given column values.

Syntax
add_row()

Arguments

Return Value
Data Frame

Example

Original Data:

ID name
4716 Oracle
4755 Rakuten
2432 DeNA

add_row(ID = 4689)

ID name
4716 Oracle
4755 Rakuten
2432 DeNA
4689 NA

add_row(ID = 4689, name = "Yahoo")

ID name
4716 Oracle
4755 Rakuten
2432 DeNA
4689 Yahoo

parse_number

概要
文字列などを除いた上で数値のみを抽出し、Numeric（数値）型に変換します。

シンタックス
parse_number(<列名>, na = c("", "NA"), locale = <ロケール>)

引数

返り値
Numeric

例
parse_number(X1) X1列の様々な形式の数値表現から純粋な数値を抽出します。整数、小数点数、通貨表記、単位付き数値に対応します。カンマ、通貨記号、単位などは除去されます。

X1 NEW
"12345" 12345
"12345.10" 12345.1
"$12,345.10" 12345.1
"$12.20M" 12.2

parse_number(X1 - X2) X1列とX2列の日付の差分を日の数値として返します。

X1 X2 NEW
2015-01-30 2015-01-15 15
2015-02-15 2015-02-01 14
2015-03-31 2015-03-15 16

parse_double

概要
データをDouble（倍精度浮動小数点数）型に変換します。

シンタックス
parse_double(<列名>, na = c("", "NA"), locale = <ロケール>)

引数

返り値
Double

例
parse_double("12345")
12345を返します。
parse_double("12345.10")
12345.1を返します。

parse_euro_double

概要
データをDouble（倍精度浮動小数点数）型に変換します。

シンタックス
parse_euro_double(<列名>, na = c("", "NA"))

引数

返り値
Double

例
parse_euro_double("12345")
12345を返します。
parse_euro_double("12345.10")
12345.1を返します。

parse_integer

概要
データをInteger（整数）型に変換します。

シンタックス
parse_integer(<列名>, na = c("", "NA"), locale = <ロケール>)

引数

返り値
Integer

例
parse_integer("12345")
12345を返します。
parse_integer("12345.10")
12345を返します。

parse_time

概要
時刻型の文字列をhms（時刻）型に変換します。

シンタックス
parse_time(as.character(<列名>), format = <時間のフォーマット>, locale = <ロケール>)

引数

返り値
time

例 parse_time(as.character(X1)) X1の時刻型の文字列をhms型に変換します。

X1 NEW
13:10:05 13:10:05

parse_time(as.character(X1), locale = locale(tz = "America/Los_Angeles")) X1の時刻型の文字列をタイムゾーンを指定してhms型に変換します。

X1 NEW
13:10:05 13:10:05

parse_time(as.character(X1)) X1の12時間形式の時刻型の文字列を24時間形式のhms型に変換します。

X1 NEW
10:20:15 PM 22:20:15

parse_time(as.character(X1), locale = locale("ja")) X1の日本語の12時間形式の時刻型の文字列を24時間形式のhms型に変換します。

X1 NEW
10:20:15 午後 22:20:15

parse_character

概要
データをCharacter（文字列）型に変換します。

シンタックス
parse_character(<列名>, na = c("", "NA"), locale = <ロケール>)

引数

返り値
Character

例
parse_character(123.11)
文字列型として"123.11"を返します。

parse_factor

概要
データをFactor（順序付きカテゴリー）型に変換します。

シンタックス
parse_factor(x, levels = c("値1", "値2", ...), na = c("", "NA"), locale = <ロケール>)

引数

返り値
Factor

例
columnA - "iMac", "iPod", "iPhone", "iPod", "iPhone"
parse_factor(columnA)
データとしてはiMac, iPod, iPhone, iPod, iPhoneを返しますが、レベルとしては出現順であるiMac, iPod, iPhoneを返します。

parse_logical

概要
データをLogical（論理値）型に変換します。

シンタックス
parse_logical(<列名>, na = c("", "NA"), locale = <ロケール>)

引数

返り値
Logical

例
parse_logical(X1) X1列の文字列をロジカル型(TRUE/FALSE)に変換します。"TRUE"/"T"はTRUE、"FALSE"/"F"はFALSEに変換されます。

X1 NEW
TRUE TRUE
T TRUE
F FALSE

type_convert

概要
Heuristically guess the data type for each column by reading the first 1000 rows, parse the data, and set appropriate data types for all the columns of the data frame.

シンタックス
type_convert()

引数

返り値
Data Frame

例
type_convert()

ym

概要

年、月の順番の文字列または数値データを日付型に変換します。

シンタックス

ym(<列名>, tz = <タイムゾーン>, locale = <ロケール>)

引数

返り値

Date

例
ym(X1) X1列のハイフン区切りの年月文字列を日付型に変換します。

X1 NEW
2015-10 2015-10-01

r ym(X1) X1列のスラッシュ区切りの年月文字列を日付型に変換します。

X1 NEW
2015/10 2015-10-01

r ym(X1) X1列の自然言語の年月文字列を日付型に変換します。

X1 NEW
Created on 2015 10 2015-10-01

ym(X1, locale = "English") X1列の英語ロケールの年月文字列を日付型に変換します。

X1 NEW
2015, Oct 2015-10-01

my

概要

月、年の順番の文字列または数値データを日付型に変換します。

シンタックス my(<列名>, tz = <タイムゾーン>, locale = <ロケール>)

引数

返り値 Date

例 my(X1) X1列のハイフン区切りの月年文字列を日付型に変換します。

X1 NEW
01-2015 2015-01-01

my(X1) X1列のスラッシュ区切りの月年文字列を日付型に変換します。

X1 NEW
01/2015 2015-01-01

my(X1) X1列の自然言語の月年文字列を日付型に変換します。

X1 NEW
Created on 1 2015 2015-01-01

my(X1, locale = "English") X1列の英語ロケールの月年文字列を日付型に変換します。

X1 NEW
Oct, 2015 2015-10-01

yq

概要

年と四半期の文字列データを日付型に変換します。

シンタックス
yq(<列名>, tz = <タイムゾーン>, locale = <ロケール>)

引数

返り値
Date

例 yq(X1) X1列のドット区切りの年四半期の文字列を日付型に変換します。

X1 NEW
2016.2 2016-04-01

yq(X1) X1列のハイフン区切りの年四半期の文字列を日付型に変換します。

X1 NEW
2016-03 2016-07-01

epiweek

概要

年の週番号を抽出します。週の開始曜日は日曜日になっています。

シンタックス
epiweek(<日付列>)

返り値
Numeric

例 epiweek(X1) X1列の日付データから年の週番号を抽出します。各週は日曜日から始まります。

X1 NEW
2020-01-03 1
2020-02-15 7
2020-03-22 13

as_date

概要

POSIXct型の列をDate型に変換できます。

シンタックス
as_date(<日付時間型の列>)

引数

返り値
Date

例
r as_date(X1) X1列の日付時間型の列を日付型に変換します。

X1 NEW
2015-10-10 13:10:05 2015-10-10
2023-12-25 09:30:00 2023-12-25
2024-01-01 00:00:00 2024-01-01

as_datetime

概要

データをPOSIXct型に変換します。

シンタックス
as_datetime(<日付>, format = <date_time_format>, tz = <タイムゾーン>, origin = <text>)

引数

返り値
POSIXct

例

as_datetime("2015-10-10 13:10:05") "2015-10-10 13:10:05 PDT"を返します。
as_datetime("2015-10-10 13:10:05", tz = "America/Los_Angeles") "2015-10-10 13:10:05 PDT"を返します。
as.as_datetime("2015-10-10 13:10:05", tz = "Asia/Tokyo") "2015-10-10 13:10:05 JST"を返します。
as_datetime("05-10-15T13:10:05", format = "%d-%m-%yT%H:%M") "2015-10-05 13:10:00 PDT"を返します。

str_squish

概要
テキストの前後にある空白を削除し、テキスト中の連続した空白を単一の半角スペースに変換します。

シンタックス
str_squish(<テキストの列>)

引数

返り値
Character

例
str_squish(X1) X1列の前後の空白を削除し、中間の空白を1つの半角スペースに変換します。

X1 NEW
String with spaces String with spaces
Hello World Hello World
Multiple white spaces Multiple white spaces

str_trunc

概要
テキストの文字数が指定された数になるように、テキストを切り捨てます。

シンタックス
str_trunc(<テキストの列>, width = <数値>, side = "right"|"left"|"center", ellipsis = <文字>)

引数

返り値
Character

例 str_trunc(X1, 6) X1列の文字列を6文字に切り詰めます。デフォルトは「...」の3文字が省略記号として表示されるため、切り詰めが発生する場合、3文字が表示されることになります。

X1 NEW
Exploratory Exp...
Data Data
Analytics Ana...

str_trunc(X1, 6, side = "left") X1列の文字列を左から6文字に切り詰めます。デフォルトは「...」の3文字が省略記号として表示されるため、切り詰めが発生する場合、3文字が表示されることになります。

X1 NEW
Exploratory ...ory
Data Data
Analytics ...ics

str_remove

概要
指定した文字列または正規表現に一致する文字列を取り除きます。

シンタックス
str_remove(<テキストの列>, <pattern>)

引数

返り値
Character

例
str_remove(X1, pattern = "New") X1列から"New"という文字列を取り除きます。

X1 NEW
New York York
New Jersey Jersey
New Mexico Mexico

str_remove_all

概要
指定した文字列または正規表現に一致する文字列をすべて取り除きます。

シンタックス
str_remove_all(<テキストの列>, <pattern>)

引数

返り値
Character

例
str_remove_all(X1, pattern = "New") X1列から全ての"New"という文字列を削除します。

X1 NEW
New York New York
New New Jersey Jersey
Old New Mexico Old Mexico

str_remove_word

概要
文章から単語を取り除きます。

シンタックス
str_remove_word(<テキストの列>, start = <数値>, end = <数値>, sep = <区切り文字>)

引数

注意: 現在は最初と最後の単語の削除のみ機能しています。

返り値
Character

例

str_remove_word(テキストの列, start = 1, sep = " ")

テキストの列から最初の単語を削除します。

テキストの列 新しい列
Hello World World
R Programming Programming
Data Analysis Analysis

str_remove_word(テキストの列, start = -1, sep = " ")

テキストの列から最後の単語を削除します。

テキストの列 新しい列
Hello World Hello
R Programming R
Data Analysis Data

str_remove_word(テキストの列, end = -1, sep = "-")

テキストの列からハイフン区切りの最後の単語を削除します。

テキストの列 新しい列
user-name-id user-name
first-last-middle first-last
Tokyo-Osaka-Kyoto Tokyo-Osaka

str_replace_word

概要
文章にある単語を指定して単語に置換します。

シンタックス
str_replace_word(<テキストの列>, start = <数値>, end = <数値>, sep = <区切り文字>, rep = <置換する文字列>)

引数

注意: 現在は最初と最後の単語の置換のみ機能しています。

返り値
Character

例

str_replace_word(テキストの列, start = -1, sep = " ", rep = "England")

テキストの列の最後の単語を指定した"England"に置換します。

テキストの列 新しい列
I am traveling to New York I am traveling to New England
Hello World Hello England
Test England

str_replace_word(テキストの列, start = 1, sep = " ", rep = "データ")

テキストの列の最初の単語を"データ"に置換します。

テキストの列 新しい列
Hello World データ World
R Programming データ Programming
Data Analysis データ Analysis

str_replace_word(テキストの列, start = 1, sep = "-", rep = "PREFIX")

テキストの列のハイフン区切りの最初の単語を"PREFIX"に置換します。

テキストの列 新しい列
user-name-id PREFIX-name-id
first-last-middle PREFIX-last-middle
Tokyo-Osaka-Kyoto PREFIX-Osaka-Kyoto

str_remove_inside

概要
指定した文字の範囲内に含まれる文字を取り除きます。

シンタックス
str_remove_inside(<テキストの列>, begin = <開始文字>, end = <終了文字>, all = <TRUE|FALSE>, include_special_chars = <TRUE|FALSE>)

引数

返り値
Character

例
str_remove_inside(X1, begin = "(", end = ")") X1列から丸括弧内の文字列を削除します。

X1 NEW
I am traveling to New York (2020) I am traveling to New York
Data (old) Analysis Data Analysis
Text (note) here Text here

str_replace_inside

概要
指定した文字の範囲内に含まれる文字を置換します。

シンタックス
str_replace_inside(<テキストの列>, begin = <開始文字>, end = <終了文字>, rep = <置換する文字>, all = <TRUE|FALSE>, include_special_chars = <TRUE|FALSE>)

引数

返り値
Character

例
str_replace_inside(X1, begin = "(", end = ")", rep = "England") X1列の括弧内の文字列を"England"に置換します。

X1 NEW
I am traveling to New (York) I am traveling to New (England)
Visit (old) City Visit (England) City
Text (2020) Text (England)

str_remove_url

概要
文字列の中にあるURLを取り除きます。

シンタックス
str_remove_url(<テキストの列>, position = <start/end/any>)

引数

返り値
Character

例
str_remove_url(X1, position = "any") X1列からURLを削除します。

X1 NEW
I am traveling to New York http://example.com I am traveling to New York
Visit https://test.com/page Visit
No URL here No URL here

str_replace_url

概要
文字列の中のURLを指定したテキストに置換します。

シンタックス
str_replace_url(<テキストの列>, rep = <テキスト>)

引数

返り値
Character

例
str_replace_url(X1, rep = "Web") X1列のURLを指定した文字列に置換します。

X1 NEW
Visit http://example.com/ny Visit Web
Check https://test.com Check Web
No URL here No URL here

str_extract_url

概要
文字列の中からURLを抽出します。

シンタックス
str_extract_url(<テキストの列>)

返り値
Character

例
str_extract_url(X1) X1列からURLを抽出します。

X1 NEW
Visit http://example.com/ny http://example.com/ny
Check https://test.com https://test.com
No URL here NA

str_remove_emoji

概要
文字列の中から絵文字を取り除きます。

シンタックス
str_remove_emoji(<テキストの列>)

返り値
Character

例
str_remove_emoji(X1) X1列から絵文字を取り除きます。

X1 NEW
I am traveling to New York 🤩 I am traveling to New York
Hello 👋 World Hello World
No emoji here No emoji here

model_info

Summary

Returns a summary information of a given model in a tidy (normalized data frame) format.

Syntax

model_info(<column_list>, output = <model_info_output_type>, ...)

Arguments
* output (Optional) - The default is "summary". This changes the type of output. Can be one of the following.

Returned Values

Example

Following examples assumes that 'model' column contains a fitted model of 'lm' by do() command.

model_info(model, output = "summary")

r.squared adj.r.squared sigma statistic p.value df logLik AIC BIC deviance df.residual
0.8879 0.8879 13.0886 1716441.58 0 3 -1729152.62 3458313.24 3458357.15 74228528.48 433295

model_info(model, output = "variables")

term estimate std.error statistic p.value
(Intercept) -3.0966 0.0341 -90.749 0
2 DEP_DELAY 1.003 0.0005 1851.9463 0
3 DISTANCE -0.0037 0 -114.3364 0

model_info(model, output = "data")

.rownames ARR_DELAY DEP_DELAY .fitted .se.fit .resid .hat .sigma .cooksd .std.resid
1 -15 -9 -13.934 0.0247 -1.066 0.0000035503 13.0886 7.8503e-9 -0.0814
2 -28 -19 -22.4116 0.035 -5.5884 0.0000071333 13.0886 4.3348e-7 -0.427

as.hms

概要
指定されたデータをhms型のデータに変換します。Hms,difftimeの値を計算で使う際には秒単位で処理されます。

シンタックス
as.hms(<列名>)

引数

返り値
hms

例
as.hms(X1) X1列の数値を秒単位で扱いhms型に変換します。

X1 NEW
20 00:00:20
3600 01:00:00
7320 02:02:00

is.hms

概要
指定したオブジェクトがhms型の場合はTRUEを返します。

シンタックス
is.hms(<列名>)

引数

返り値
Logical

例
is.hms(X1) X1列がhms型かどうかをロジカル型（TRUEまたはFALSE）で返します。

X1 NEW
12:34:56 TRUE
09:45:00 TRUE
15:30:22 TRUE

mutate_if(is.hms, ~as.numeric(.)) hms型の列を全て秒数（数値）に変換します。

X1 NEW
9:00:00 32400
8:45:00 31500
9:30:00 34200

remove_empty

概要
空の行や列を削除します。データフレームから空（NA、NULL、空白）の行や列を取り除くのに便利です。

シンタックス
remove_empty(<データフレーム>, which = <"rows"|"cols">, quiet = <TRUE|FALSE>)

引数

返り値
data.frame

例

元のデータ:

名前 年齢 都市
鈴木 25 東京
NA NA NA
田中 30 大阪

remove_empty(データフレーム, which = "rows") すべての列がNA、NULL、または空白値の行を削除します。

名前 年齢 都市
鈴木 25 東京
田中 30 大阪

元のデータ:

名前 年齢 都市 備考
鈴木 25 東京 NA
田中 30 大阪 NA
佐藤 28 名古屋 NA

remove_empty(データフレーム, which = "cols") すべての行がNA、NULL、または空白値の列を削除します。

名前 年齢 都市
鈴木 25 東京
田中 30 大阪
佐藤 28 名古屋

元のデータ:

名前 年齢 都市 備考
鈴木 25 東京 NA
NA NA NA NA
田中 30 大阪 NA

remove_empty(データフレーム, which = c("rows", "cols")) 空の行と列の両方を削除します。

名前 年齢 都市
鈴木 25 東京
田中 30 大阪

clean_names

概要
列名をアンダースコア（_）、小文字のアルファベット、数字のみを使用してきれいな列名の形式に変換します。

シンタックス
clean_names(<データフレーム>, case = <"変換後の形式">)

引数

返り値
data.frame

例

clean_names(データフレーム)

元のデータ:

Item Name .transaction
banana 1
apple 1
carrot 2
apple 2
orange 3
NA 3

clean_names()をデフォルト設定（snake_case）で適用した結果:

item_name transaction
banana 1
apple 1
carrot 2
apple 2
orange 3
NA 3

clean_names(データフレーム, case = "upper_camel")

case="upper_camel"を指定した場合（キャメルケース、先頭大文字）

ItemName Transaction
banana 1
apple 1
carrot 2
apple 2
orange 3
NA 3

get_dupes

概要
指定した列（複数可）で重複している行を抽出します。何も指定しない場合、全ての列で重複している行を対象とします。

シンタックス
get_dupes(<列名1>, <列名2>, ...)

引数

返り値
data.frame（元のデータフレームから重複している行のみを抽出し、重複回数を示す「dupe_count」列が追加されます）

例

get_dupes(name)

元のデータ:

name n
banana 1
apple 1
apple 1
apple 2

name列で重複している行を返します（重複回数を示すdupe_count列が追加されます）

name n dupe_count
apple 1 2
apple 1 2
apple 2 1

get_dupes(name, n)

name列とn列の組み合わせで重複している行を返します:

name n dupe_count
apple 1 2
apple 1 2

excel_numeric_to_date

概要
Excelの日付の数値（例: 42370）を日付型（例: 2016-01-01）に変換します。

シンタックス
excel_numeric_to_date(<数値列>, date_system = "modern"|"mac pre-2011")

引数

例

元のデータ:

user last_login
Lisa 42370
Emily 42318
John 42489

excel_numeric_to_date(last_login) Excelの日付の数値を日付型に変換した下記の結果を返します。

user last_login
Lisa 2016-01-01
Emily 2015-11-10
John 2016-04-29

返り値
Date

tabyl

概要
指定した列の頻度表を作成します。データの分布を素早く把握するのに役立ちます。パーセント表示やNA値の処理にも対応しています。

シンタックス
tabyl(<列名>, sort = <TRUE|FALSE>, show_na = <TRUE|FALSE>, show_missing_levels = <TRUE|FALSE>)

引数

返り値
data.frame（頻度表）

例

tabyl(データフレーム, item_name)

元のデータ:

item_name transaction_id
banana 1
apple 1
NA NA
carrot 2
apple 2
NA NA
orange 3
NA 3

item_name列の頻度表（NAを含む）:

item_name n percent valid_percent
apple 2 0.250 0.40
banana 1 0.125 0.20
carrot 1 0.125 0.20
orange 1 0.125 0.20
NA 3 0.375 NA

tabyl(データフレーム, item_name, sort = TRUE)

頻度の高い順に並べ替えた例:

item_name n percent valid_percent
NA 3 0.375 NA
apple 2 0.250 0.40
banana 1 0.125 0.20
carrot 1 0.125 0.20
orange 1 0.125 0.20

tabyl(データフレーム, item_name, show_na = FALSE)

NA値を除外した例:

item_name n percent
apple 2 0.40
banana 1 0.20
carrot 1 0.20
orange 1 0.20

as_factor

概要

指定した列を順序付きカテゴリーの列に変換します。標準搭載のbase関数のas.factor との違いは、出現する順序でレベルを作成する点です。またすべてのプラットフォームで同じ挙動です。 (base関数はロケールでソートするため、環境に応じて結果が変わる可能性があります)

シンタックス
as_factor(<列名>)

引数

例
as_factor(X1) X1列をファクター型に変換し、データの出現順でレベルを設定します。出力列のレベルは最初に現れた順（Red, Blue, Green）となります。

X1 NEW
Red Red
Blue Blue
Green Green

fct_anon

概要 順序付きカテゴリーのレベルを匿名化し、任意の数値に置き換えます。値もレベルの順序も保持されません。

シンタックス
fct_anon(<列名>, prefix = <文字列>)

引数

例

fct_anon(X1) X1列の順序付きのカテゴリーを1から始まるランダムな数値に置き換えます。

X1 NEW
Red 2
Blue 1
Green 3
Red 2

fct_expand

概要
ファクター型の列にレベルを追加します。

シンタックス
fct_expand(<列名>, <文字列>)

引数

例
fct_expand(X1, "JP", "CA") ファクター型のX1列の既存のレベル（FR, US）に新しいレベル（JP, CA）を追加します。データ上は存在していなくてもサマリビューやチャートで、新しいレベル（JP, CA）が表示されるようになります。

X1 NEW
FR FR
US US
FR FR

fct_drop

概要
ファクター型の列から不要なレベルを削除します。

シンタックス
fct_drop(<列名>, only = <文字列>)

引数

例
fct_drop(X1) X1列から未使用のレベルを削除します。仮に元のレベルが（FR, US, JP, CA）の場合、実データにある（FR, US）のみがレベルとして保持されます。

X1 NEW
FR FR
US US
FR FR

fct_drop(X1, only = "CA") X1列から指定したレベル（CA）のみを削除します。仮に元のレベルが（FR, US, JP, CA）の場合、実データにある（FR, US, JP）のみがレベルとして保持されます。

X1 NEW
FR FR
US US
FR FR

fct_explicit_na

概要
欠損値にレベルが与えられ、欠損値がカテゴリーとして確実にチャートで表示されるようになります。

シンタックス
fct_explicit_na(<列名>, na_level = <文字列>)

引数

例
fct_explicit_na(X1, "値なし") X1列のNAを指定した文字列（今回は"値なし"）に置き換えます。元のレベルの後に"値なし"が追加されます。

X1 NEW
FR FR
NA 値なし
US US

fct_lump

概要

データタイプをfactor型にし、値の出現頻度に応じて、出現頻度が低い値を「Other」グループにします。

シンタックス
fct_lump(<列>, n = <残すカテゴリー数>, prop = <数値>, other_level = <テキスト>, ties.method = <メソッドのタイプ>, w = <数値列>)

引数

引数のnとpropの両方が指定されていない場合、fct_lumpは最も頻度の低い値を「Other」グループにまとめ、「Other」は最小のレベルとなります。

例
fct_lump(X1, n = 3) X1列で頻度の高い上位3カ国を保持し、それ以外を"Other"にまとめます。Otherが最後のレベルとして設定されます。

X1 NEW
USA USA
Japan Japan
China China
USA USA
Japan Japan
Korea Other
USA USA
UK Other
Japan Japan
USA USA
China China
Brazil Other
USA USA
Mexico Other
Australia Other

fct_lump(X1, prop = .1) X1列で全体の20%以上の頻度を持つ国を保持し、それ以外を"Other"にまとめます。

X1 NEW
USA USA
Japan Japan
China Other
USA USA
Japan Japan
Korea Other
USA USA
UK Other
Japan Japan
USA USA
China Other
Brazil Other
USA USA
Mexico Other

fct_lump(X1, n = 3, w = X2) X1列で重み（X2：売上高）の合計が大きい上位5カ国を保持し、それ以外を"Other"にまとめます。

X1 X2 NEW
Japan 1500 Japan
USA 2000 USA
China 1800 China
Korea 1200 Other
UK 1100 Other

fct_other

概要
指定した値を「Other」グループにまとめる、または指定した値以外を「Other」グループにまとめることができます。

シンタックス
fct_other(<列>, keep = c("<値（複数）>"), drop = c("<値（複数）>"), other_level = <テキスト>)

引数

例
fct_other(X1, keep = c("Japan", "USA", "UK")) X1列で指定した国のみを保持し、それ以外を"Other"にまとめます。

X1 NEW
Japan Japan
Germany Other
USA USA
France Other
UK UK

fct_other(X1, drop = c("Japan", "USA", "UK")) X1列で指定した国を"Other"にまとめ、それ以外を保持します。

X1 NEW
Japan Other
Germany Germany
USA Other
France France
UK Other

fct_inorder

概要
元のデータ順に基づき値に順序をつけ、データタイプをfactor型に変換します。

シンタックス
fct_inorder(<factor型にしたい列>, ordered = <logical>)

引数

例
fct_inorder(X1) X1列のデータをファクター型に変換し、データの出現順でレベルを設定します。仮に元のレベルが JP、FR、USの順だった場合、FR、US、JPの順に変わります。

X1 NEW
FR FR
US US
JP JP

fct_infreq

概要
値の頻度をもとに順序をつけ、データタイプをfactor型に変換します。

シンタックス fct_infreq(<factor型にしたい列>, ordered = <TRUE/FALSE>)

引数

例
fct_infreq(X1) X1列のデータをファクター型に変換し、出現頻度が高い順（US、FR、JP）でレベルを設定します。

X1 NEW
US US
FR FR
US US
JP JP
US US
FR FR

fct_relevel

概要

値の順序を指定し、データタイプをfactor型に変換します。

シンタックス
fct_relevel(<factor型にしたい列>, ...)

引数

例
fct_relevel(X1, "Japan") X1列のレベルを指定してファクター型のデータに変換します。仮に元のレベルが France > UK > USA > Japan > Germany > Italy の順だった場合、Japan > France > UK > USA > Germany > Italy の順に変わります。なお、元のデータタイプがCharacter型の場合は、指定した"Japan"以外は、アルファベット順で値の順序がつけられます。

X1 NEW
France France
UK UK
USA USA
Japan Japan
Germany Germany
Italy Italy

fct_relevel(X1, "Japan", "USA") X1列のレベルを指定してファクター型のデータに変換します。仮に元のレベルが France > UK > USA > Japan > Germany > Italy の順だった場合、Japan > USA > France > UK > Germany > Italy の順に変わります。

X1 NEW
France France
UK UK
USA USA
Japan Japan
Germany Germany
Italy Italy

fct_reorder

概要
別の列のソートした値に基づいて値の順序を設定し、データタイプをfactor型に変換します。

シンタックス

fct_reorder(<factor型にしたい列>, <数値列>, .fun = <集計関数>, ..., .desc = <TRUE/FALSE>)

引数

例
fct_reorder(Country, Sales) Country列に対して、Sales列の値（中央値）の昇順でレベルを設定します。Sales列の中央値はFrance(500) < Japan(1000) < USA(2000)の順となるため、この順でレベルが設定されます。

Country Sales NEW
Japan 1000 Japan
Japan 1200 Japan
Japan 800 Japan
USA 2000 USA
USA 2200 USA
USA 1800 USA
France 500 France
France 600 France
France 400 France

fct_reorder(Country, Sales, .desc = TRUE) Country列に対して、Sales列の値（中央値）の降順でレベルを設定します。Sales列の中央値はUSA(2000) > Japan(1000) > France(500)の順となるため、この順でレベルが設定されます。

Country Sales NEW
Japan 1000 Japan
Japan 1200 Japan
Japan 800 Japan
USA 2000 USA
USA 2200 USA
USA 1800 USA
France 500 France
France 600 France
France 400 France

fct_reorder(Country, Sales, .fun = sum, .desc = TRUE, na.rm = TRUE) Country列に対して、Sales列の合計値の降順でレベルを設定します。Sales列の合計値はUSA(6000) > Japan(3000) > France(900)の順となるため、この順でレベルが設定されます。

Country Sales NEW
Japan 1000 Japan
Japan 1200 Japan
Japan 800 Japan
USA 2000 USA
USA 2200 USA
USA 1800 USA
France 500 France
France NA France
France 400 France

fct_rev

概要
factor型の列のレベルを反転させます。

シンタックス

fct_rev(<factor型の列>)

Arguments

例
fct_rev(X1) X1列のファクター型のレベルの順序を逆転させます。仮に元のレベルが Japan > USA > France の順だった場合、France > USA > Japan の順に変わります。

X1 NEW
Japan Japan
USA USA
France France

xgboost_reg

Summary
Create extreme gradient boosting model for regression.

Syntax
xgboost_reg(watchlist_rate = <numeric>, output_type = <xgb_reg_output_type>, nrounds = <integer>, booster = <xgboost_booster_type>, eval_metric = <xgb_reg_evaluation_type>, weight = <column_num>, early_stopping_rounds = <integer>)

Arguments

Return Value
Model

Example

Original data:

CARRIER ARR_DELAY DEP_DELAY DISTANCE
UA 10 7 300
UA 20 30 1000
UA -5 0 200
AA 20 20 500
AA -5 3 700
AA 10 8 1000

%>% group_by(CARRIER)

%>% build_model(model_func = xgboost_reg, formula = DEP_DELAY ~ ARR_DELAY + DISTANCE, test_rate = 0.1)
Returns a data frame that stores a xgb.Booster model based on a formula defined as 'Predict DEP_DELAY based on ARR_DELAY and DISTANCE.' It also returns a column of original data.

CARRIER source_data model .test_index
UA source dataframe xgb.Booster model c(1)
AA source dataframe xgb.Booster model c(2)

You can use model_coef or model_stats function to get the summary information about the models. Also, you can use prediction function to predict with the data that is stored in the same data frame.

xgboost_binary

Summary
Create extreme gradient boosting model for binary classification.

Syntax
xgboost_binary(watchlist_rate = <numeric>, output_type = <xgb_binary_output_type>, nrounds = <integer>, booster = <xgboost_booster_type>, eval_metric = <xgb_binary_evaluation_type>, weight = <column_num>, early_stopping_rounds = <integer>)

Arguments

Return Value
Model

xgboost_multi

Summary
Create extreme gradient boosting model for binary classification.

Syntax
xgboost_multi(watchlist_rate = <numeric>, output_type = <xgb_multi_output_type>, nrounds = <integer>, booster = <xgboost_booster_type>, eval_metric = <xgb_multi_evaluation_type>, weight = <column_num>, early_stopping_rounds = <integer>)

Arguments

Return Value
Model

Example

randomForestReg

Summary
Create random forest model for regression.

Syntax
randomForestReg(subset = <column_logical>, na.action = <'na_action_type'>, ntree = <integer>, mtry = <numeric>, replace = <logical>, strata = <column>, sampsize = <integer>, nodesize = <integer>, maxnodes = <integer>, importance = <logical>, localImp = <logical>, nPerm = <integer>, proximity = <logical>, oob.prox = <logical>, keep.forest = <logical>, corr.bias = <logical>, keep.inbag = <logical>)

Arguments

Return Value
Model

Example

randomForestBinary

Summary
Create random forest model for binary classification.

Syntax
randomForestReg(subset = <column_logical>, na.action = <'na_action_type'>, ntree = <integer>, mtry = <numeric>, replace = <logical>, classwt = <numeric>, cutoff = <numeric>, strata = <column>, sampsize = <integer>, nodesize = <integer>, maxnodes = <integer>, importance = <logical>, localImp = <logical>, nPerm = <integer>, proximity = <logical>, oob.prox = <logical>, norm.votes = <logical>, keep.forest = <logical>, corr.bias = <logical>, keep.inbag = <logical>)

Arguments

Return Value
Model

Example

randomForestMulti

Summary
Create random forest model for multi class classification.

Syntax
randomForestReg(subset = <column_logical>, na.action = <'na_action_type'>, ntree = <integer>, mtry = <numeric>, replace = <logical>, classwt = <numeric>, cutoff = <numeric>, strata = <column>, sampsize = <integer>, nodesize = <integer>, maxnodes = <integer>, importance = <logical>, localImp = <logical>, nPerm = <integer>, proximity = <logical>, oob.prox = <logical>, norm.votes = <logical>, keep.forest = <logical>, corr.bias = <logical>, keep.inbag = <logical>)

Arguments

Return Value
Model

Example

list_extract

概要
リスト内のデータがデータフレームの場合、位置または名前をもとにリストのデータ型の列の値を抽出します。

シンタックス
list_extract(<リストの列>, position = <数値>, rownum = <数値>)

引数

返り値
Character

例

1) 列は文字列のリストの場合

mutate(テキスト= list_extract(カテゴリー, 1))
以下の結果を返します。

カテゴリー テキスト
c("Doctors", "Health & Medical") Doctors
c("Bars", "American (New)", "Nightlife") Bars

mutate(テキスト = list_extract(カテゴリー, -1))
最後から1番目の要素の値を返します。

カテゴリー テキスト
c("Doctors", "Health & Medical") Health & Medical
c("Bars", "American (New)", "Nightlife") Nightlife

2) 列がデータフレームのリストの場合

mutate(テキスト = list_extract(ラベル, 1))
1列目と1行目の値を返します。指定がない場合、デフォルトで1行目の値を返します。

ラベル テキスト
list(name = c("Regression", "UI"), color = c("5319e7", "207de5")) Regression

mutate(テキスト = list_extract(ラベル, -1))
最後の列と最初の行の値を返します。

ラベル テキスト
list(name = c("Regression", "UI"), color = c("5319e7", "207de5")) 5319e7

mutate(text = list_extract(labels, 1, 2))
1列目の2行目の値を返します。

ラベル テキスト
list(name = c("Regression", "UI"), color = c("5319e7", "207de5")) UI

mutate(text = list_extract(labels, "name"))
列「name」と最初の行の値を返します。 指定がない場合、デフォルトは 1 行目の値を返します。

ラベル テキスト
list(name = c("Regression", "UI"), color = c("5319e7", "207de5")) Regression

list_to_text

概要
リストデータ型の列のすべての要素のテキストを連結します。

シンタックス
list_to_text(<リストの列> , sep = <文字列>)

引数

返り値
character

例

mutate(カテゴリーのテキスト = list_to_text(カテゴリー))
以下の結果を返します

カテゴリー カテゴリーのテキスト
c("Doctors", "Health & Medical") Doctors, Health & Medical
Nightlife Nightlife
c("Active Life", "Mini Golf", "Golf") Active Life, Mini Golf, Golf
c("Bars", "American (New)", "Nightlife") Bars, American (New), Nightlife
c("Bars", "American (Traditional)", "Nightlife") Bars, American (Traditional), Nightlife

list_concat

概要
複数の列の値をリストとして連結します。

シンタックス
list_concat(<列名>, collapse = <TRUE|FALSE>)

引数

返り値
list

例

mutate(連結した項目 = list_concat(項目1, 項目2))
以下の結果を返します。

Before:

名前 項目1 項目2
Cathy c("Banana", "Apple") "Apple"
Mary "Lemon" c("Lemon", "Banana")
Lisa c("Lemon", "Banana") c("Banana", "Apple")

After:

名前 項目1 項目2 連結した項目
Cathy c("Banana", "Apple") "Apple" c("Banana", "Apple", "Apple")
Mary "Lemon" c("Lemon", "Banana") c("Lemon", "Lemon", "Banana")
Lisa c("Lemon", "Banana") c("Banana", "Apple") c("Lemon", "Banana", "Banana", "Apple")

summarize(カテゴリー = list_concat(カテゴリー, collapse = TRUE))
以下の結果を返します。

Before:

"地域"でグループ化

地域 カテゴリー
East c("Doctors", "Health & Medical")
East Nightlife
East c("Active Life", "Mini Golf", "Golf")
West c("Bars", "American (New)", "Nightlife")
West c("Bars", "American (Traditional)", "Nightlife")

After:

region カテゴリー
East c("Doctors", "Health & Medical", "Nightlife", "Active Life", "Mini Golf", "Golf")
West c("Bars", "American (New)", "Nightlife", "Bars", "American (Traditional)", "Nightlife")

list_n

概要
行ごとにリストデータ型の列内の要素の数を返します。

シンタックス
list_n(<リスト型の列>)

引数

返り値
Numeric

例

mutate(要素数 = list_n(カテゴリー)) 以下の結果が返ります。

カテゴリー 要素数
c("Doctors", "Health & Medical") 2
Nightlife 1
c("Active Life", "Mini Golf", "Golf") 3
c("Bars", "American (New)", "Nightlife", "Lounges", "Restaurants") 5
c("Bars", "American (Traditional)", "Nightlife", "Restaurants") 4

normalize

概要
列の数値を標準化を行います。標準化後のデータは、平均値が0、標準偏差が1になります。

シンタックス
normalize(<数値列>, center = <TRUE|FALSE>, scale = <TRUE|FALSE>)

引数

返り値
Numeric

例
normalize(X1, center = 0) 0をセンタリングの基準値にして、スケーリングします。

X1 NEW
1 -0.458460972
2 -0.4332245882
3 -0.4079882045
4 -0.3827518207
5 -0.3575154369
100 2.039941022

(X1 - mean(X1)) / sd(X1) 上記の計算をすると同じ結果を得られます。

normalize(X1, center = FALSE) センタリングを行わずに、列の数値をスケーリングします。

X1 NEW
1 0.0222994404
2 0.04459888081
3 0.06689832121
4 0.08919776161
5 0.111497202
100 2.22994404

X1 / sqrt(sum(X1^2)/(length(X1)-1)) 上記の計算をすると同じ結果を得られます。

normalize(X1, center = 0, scale = max(X1)) X1の値範囲が0から1になるようにスケーリングします。

X1 NEW
1 0.01
2 0.02
3 0.03
4 0.04
5 0.05
100 1

anonymize

概要
ハッシュ・アルゴリズムによって値を匿名化します。

シンタックス
anonymize(<列名>, algo = <アルゴリズム>, seed = <整数値>, chars = <文字列>, n_chars = <整数値>)

引数

例
anonymize(X1, algo = "murmur32") X1列の値をmurmur32アルゴリズムを使用して匿名化します。

X1 NEW
6fe21ea2 1482148710
6fe21ea2 1482148710
2f968d4a 1479913692

返り値
Character

excel_numeric_to_datetime

概要 Excelで数値になっている日付/時刻の値をPOSIXct型の値に変換します。

シンタックス
excel_numeric_to_datetime(<数値列>, tz = <タイムゾーン>)

引数

例

Original data:

顧客名 最後のログイン日時
Lisa 42370.5
Emily 42318.25
John 42489.75

mutate(最後のログイン日時 = excel_numeric_to_datetime(最後のログイン日時)) 最後のログイン日時がPOSIXctに変換されたデータフレームを返します。

顧客名 最後のログイン日時
Lisa 2016-01-01 12:00:00
Emily 2015-11-10 06:00:00
John 2016-04-29 18:00:00

返り値
POSIXct

unixtime_to_datetime

概要
unix時間の数値をPOSIXctに変換します。

シンタックス
unixtime_to_datetime(<数値列>)

例

Original data:

顧客名 最後のログイン日時
Lisa 1482148710
Emily 1479913692
John 1481128318

mutate(最後のログイン日時 = unixtime_to_datetime(最後のログイン日時)) 最後のログイン日時の列がPOSIXctに変換されたデータフレームを返します。

顧客名 最後のログイン日時
Lisa 2016-12-19 11:58:30 GMT
Emily 2016-11-23 15:08:12 GMT
John 2016-12-07 16:31:58 GMT

返り値
Date, POSIXct

do_svd.kv

概要
SVD(特異値分解)を使用して次元削減を行い、座標を計算します。

シンタックス
do_svd.kv(<主体列>, <キー列>, <値列>, type = <SVDタイプ>, fill = <数値>, fun.aggregate = <集約関数>, n_component = <整数>, centering = <論理値>, output = <出力形式>)

引数

返り値
Data frame

例

元のデータ:

author_name keywords tfidf_value
Cathy party 3.2
Cathy exciting 1.3
Cathy friends 0.8
Mary study 2.4
Mary exam 2.1
Mary hard 1.5
Lisa sports 1.9
Lisa exciting 1.8
Lisa hard 1.6

do_svd.kv(document_name, keywords, tfidf_value, n_component=2)

キーワードの次元を2に削減し、結果を'long'形式で返します。

author_name new.dimension value
Cathy 1 -0.7131255
Cathy 2 0.3976414
Lisa 1 0.0121952
Lisa 2 -0.8164055
Mary 1 0.7009303
Mary 2 0.4187641

do_svd.kv(name, key, value, n_component=2, output="wide")

キーワードの次元を2に削減し、結果を'wide'形式で返します。

author_name axis1 axis2
Cathy -0.7131255 0.3976414
Lisa 0.0121952 -0.8164055
Mary 0.7009303 0.4187641

do_svd.kv(name, key, value, n_component=2, type="dimension")

キーワードの次元を2に削減し、'dimensions'タイプで結果を返します。

top_key_words new.dimension value
exam 1 0.4163953
exam 2 0.3259924
exciting 1 -0.2560436
exciting 2 -0.3531243
friends 1 -0.1613866
friends 2 0.1179235
hard 1 0.3029449
hard 2 -0.2513704
party 1 -0.6455466
party 2 0.4716940
sports 1 0.0065547
sports 2 -0.5750138
study 1 0.4758803
study 2 0.3725628

do_svd.kv(name, key, value, n_component=2, type="variance")

キーワードの次元を2に削減し、各次元の'variance'値を返します。

new.dimension value
1 3.534991
2 2.697623

do_svd

概要
SVD(特異値分解)を使用して次元削減を行い、座標を計算します。

シンタックス
do_svd(<列名>, skv = <文字列ベクトル>, type = <SVDタイプ>, fill = <数値>, fun.aggregate = <集約関数>, n_component = <整数>, centering = <論理値>, output = <出力形式>)

引数

返り値
Data frame

例

元のデータ（通常の行列形式）:

year Als Bea Bor
1900 35.02899 18 18.14896
1901 24.02899 10 10.64896
1902 45.02899 27 20.64896

do_svd(-year)

yearを除く列に対してSVDを実行し、以下のような結果を返します:

pair.name.1 pair.name.2 value
Als Bea 28.492868
Als Bor 32.532238
Bea Als 28.492868
Bea Bor 6.385847
Bor Als 32.532238
Bor Bea 6.385847

元のデータ（キー・バリュー形式）:

date name product num
2015-06-12 Lisa orange 5
2015-06-12 Emily apple 3
2015-06-12 John carrot 3
2015-06-13 Emily apple 4
2015-06-13 John apple 6
2015-06-16 Lisa orange 2
2015-06-16 John carrot 4
2015-06-16 Emily orange 7

do_svd(skv = c("name", "product", "num"))

name列を主体、product列をキー、num列を値としてSVDを実行し、以下のような結果を返します:

name dimension1 dimension2
Emily -0.712526 0.397641
John 0.012195 -0.816406
Lisa 0.700930 0.418764

do_svd(skv = c("name", "product", "num"), fun.aggregate=sum, type="variance")

同じデータに対して分散タイプの出力を指定すると、以下のような結果を返します:

dimension value
1 3.534991
2 2.697623

build_lm

概要
線形回帰モデル(lm)を作成し、データフレームに格納します。

シンタックス
build_lm(<数式>, test_rate = <数値>, subset = <数値ベクトル>, weights = <数値ベクトル>, na.action = <NA処理方法>, method = <lm計算方法>, model = <論理値>, x = <論理値>, y = <論理値>, qr = <論理値>, singular.ok = <論理値>, contrasts = <リスト>, offset = <数値ベクトル>)

引数

返り値
Data frame

例

元のデータ:

CARRIER ARR_DELAY DEP_DELAY DISTANCE
UA 10 7 300
UA 20 30 1000
UA -5 0 200
AA 20 20 500
AA -5 3 700
AA 10 8 1000

group_by(CARRIER) %>% build_lm(ARR_DELAY ~ DEP_DELAY + DISTANCE, test_rate = 0.1)

CARRIERでグループ化し、「ARR_DELAYをDEP_DELAYとDISTANCEから予測する」という数式で線形回帰モデルを作成します。データの10%をテストデータとして使用します。以下のような結果を返します：

CARRIER source_data model .test_index
UA source dataframe lm model c(1)
AA source dataframe lm model c(2)

作成されたモデルの要約情報を取得するにはmodel_coefまたはmodel_stats関数を使用できます。また、予測を行うにはprediction関数を使用できます。

do_survfit

概要
生存時間データから生存曲線を計算します。なお日付列のみでは生存曲線は計算できないため、開始日を表す列と終了日を表す列などから、あらかじめweeks_between()、months_between()、years_between()関数などを使って、期間の情報を計算しておく必要があります。

シンタックス
do_survfit(<生存期間の数値列>, <生存状態の列>, weights = <数値ベクトル>, subset = <数値ベクトル>, na.action = <NA処理方法>, id = <ID列>, istate = <状態列>, type = <生存曲線のタイプ>, error = <survfitのエラータイプ>, conf.type = <survfitの信頼区間タイプ>, conf.lower = <survfitの下限信頼区間タイプ>, conf.int = <数値>, se.fit = <論理値>, influence = <論理値>)

引数

返り値
Data frame

例

元のデータ:

開始日 終了日 利用月数 キャンセル 性別
2021-12 2025-03 40 TRUE 男性
2022-06 2025-03 30 TRUE 女性
2022-07 2025-03 35 FALSE 男性
2024-08 2025-03 8 FALSE 女性
2021-12 2025-03 40 TRUE 女性
2022-06 2025-03 30 TRUE 男性
2022-07 2025-03 35 FALSE 女性
2024-08 2025-03 8 FALSE 男性

do_survfit(利用月数, キャンセル) 生存時間分析を実行し、生存曲線（生存率）を作成します:

time n_risk n_event n_censor estimate std_error conf_high conf_low
8 8 0 2 1.0000000 0.0000000 1 1.0000000
30 6 2 0 0.6666667 0.1924501 1 0.3744997
35 4 0 2 0.6666667 0.1924501 1 0.3744997
40 2 2 0 0.0000000 Inf NA NA

結果の説明: - time: 時点 - n_risk: その時点でのリスク集合の大きさ(対象者数) - n_event: イベント(死亡など)が発生した数 - n_censor: 打ち切り(追跡不能など)が発生した数 - estimate: 推定された生存確率 - std_error: 標準誤差 - conf_high/conf_low: 信頼区間の上限/下限

mutate(`生存期間` = years_between(`開始日`, `終了日`)) %>% do_survfit(`生存期間`, `キャンセル`) %>% filter(as.integer(`生存期間`) == `生存期間`) 生存時間分析を実行し、年単位の生存曲線（年間/年ごとの生存率）を計算します:

mutate(`生存期間` = months_between(`開始日`, `終了日`)) %>% do_survfit(`生存期間`, `キャンセル`) %>% filter(as.integer(`生存期間`) == `生存期間`) 生存時間分析を実行し、月単位の生存曲線（月間/月ごとの生存率）を計算します:

mutate(`生存期間` = weeks_between(`開始日`, `終了日`)) %>% do_survfit(`生存期間`, `キャンセル`) %>% filter(as.integer(`生存期間`) == `生存期間`) 生存時間分析を実行し、週単位の生存曲線（週間/週ごとの生存率）を計算します:

mutate(`生存期間` = years_between(`開始日`, `終了日`)) %>% group_by(`性別`) %>% do_survfit(`生存期間`, `キャンセル`) %>% filter(as.integer(`生存期間`) == `生存期間`) 性別ごとに生存時間分析を実行し、年単位の生存曲線（年間/年ごとの生存率）を計算します:

mutate(`生存期間` = months_between(`開始日`, `終了日`)) %>% group_by(`性別`) %>% do_survfit(`生存期間`, `キャンセル`) %>% filter(as.integer(`生存期間`) == `生存期間`) 性別ごとに生存時間分析を実行し、月単位の生存曲線（月間/月ごとの生存率）を計算します:

mutate(`生存期間` = weeks_between(`開始日`, `終了日`)) %>% group_by(`性別`) %>% do_survfit(`生存期間`, `キャンセル`) %>% filter(as.integer(`生存期間`) == `生存期間`) 性別ごとに生存時間分析を実行し、週単位の生存曲線（週間/週ごとの生存率）を計算します:

prediction_survfit

概要
生存モデルに基づいて、指定されたコホートの生存曲線をシミュレーションします。

シンタックス
prediction_survfit(newdata = <コホートデータセット>, na.action = <NA処理方法>, type = <生存曲線のタイプ>, conf.type = <survfitの信頼区間タイプ>, conf.int = <数値>, se.fit = <論理値>, censor = <論理値>, start.time = <数値>)

引数

返り値
Data frame

例

元のデータ（事前にモデルが構築されているデータフレーム）:

prediction_survfit(newdata = data.frame(age = c(50, 60), sex = c(0, 1)))

年齢と性別の新しい組み合わせについて生存曲線をシミュレーションし、以下のような結果を返します:

time n_risk n_event n_censor age_sex estimate std_error conf_high conf_low
8 4 0 1 50_0: 1.0000000 0.0000000 1 1.0000000
30 3 1 0 50_0: 0.6666667 0.4082483 1 0.2995071
35 2 0 1 50_0: 0.6666667 0.4082483 1 0.2995071
40 1 1 0 50_0: 0.0000000 Inf NA NA

build_lr

概要
ロジスティック回帰モデルを作成し、データフレームに格納します。

シンタックス
build_lr(<数式>, test_rate = <数値>, weights = <数値ベクトル>, subset = <数値ベクトル>, na.action = <NA処理方法>, start = <数値ベクトル>, etastart = <数値ベクトル>, mustart = <数値ベクトル>, offset = <数値ベクトル>, epsilon = <数値>, maxit = <整数>, trace = <論理値>, model = <論理値>, method = <glm計算方法>, contrasts = <リスト>, x = <論理値>, y = <論理値>)

引数

例

元のデータ:

CARRIER IS_DELAYED DEP_DELAY DISTANCE
UA TRUE 7 300
UA TRUE 30 1000
UA FALSE 0 200
AA TRUE 20 500
AA FALSE 3 700
AA TRUE 8 1000

group_by(CARRIER) %>% build_lr(IS_DELAYED ~ DEP_DELAY + DISTANCE, test_rate = 0.1)

CARRIERでグループ化し、「IS_DELAYEDをDEP_DELAYとDISTANCEから予測する」という数式でロジスティック回帰モデルを作成します。データの10%をテストデータとして使用します。以下のような結果を返します：

CARRIER source_data model .test_index
UA source dataframe glm model c(1)
AA source dataframe glm model c(2)

作成されたモデルの要約情報を取得するにはmodel_coefまたはmodel_stats関数を使用できます。また、予測を行うにはprediction関数を使用できます。

build_glm

概要
一般化線形モデル(glm)を作成し、データフレームに格納します。

シンタックス
build_glm(<数式>, test_rate = <数値>, family = <glmファミリータイプ>, weights = <数値ベクトル>, subset = <数値ベクトル>, na.action = <NA処理方法>, start = <数値ベクトル>, etastart = <数値ベクトル>, mustart = <数値ベクトル>, offset = <数値ベクトル>, epsilon = <数値>, maxit = <整数>, trace = <論理値>, model = <論理値>, method = <glm計算方法>, contrasts = <リスト>, x = <論理値>, y = <論理値>)

引数

例

元のデータ:

CARRIER ARR_DELAY DEP_DELAY DISTANCE
UA 10 7 300
UA 20 30 1000
UA -5 0 200
AA 20 20 500
AA -5 3 700
AA 10 8 1000

group_by(CARRIER) %>% build_glm(ARR_DELAY ~ DEP_DELAY + DISTANCE, test_rate = 0.1)

CARRIERでグループ化し、「ARR_DELAYをDEP_DELAYとDISTANCEから予測する」という数式で一般化線形モデルを作成します。データの10%をテストデータとして使用します。以下のような結果を返します：

CARRIER source_data model .test_index
UA source dataframe lm model c(1)
AA source dataframe lm model c(2)

作成されたモデルの要約情報を取得するにはmodel_coefまたはmodel_stats関数を使用できます。また、予測を行うにはprediction関数を使用できます。

build_multinom

概要
多項ロジスティック回帰モデルを作成し、データフレームに格納します。

シンタックス
build_multinom(<数式>, test_rate = <数値>, subset = <数値ベクトル>, weights = <数値ベクトル>, na.action = <NA処理方法>, Hess = <論理値>, summ = <multinom集計タイプ>, censored = <論理値>, model = <論理値>, contrasts = <リスト>)

引数

例

元のデータ:

CARRIER ARR_DELAY DEP_DELAY DISTANCE
UA 10 7 300
UA 20 30 1000
DL -5 0 200
AA 20 20 500
AA -5 3 700
AA 10 8 1000

build_multinom(CARRIER ~ ARR_DELAY + DEP_DELAY, test_rate = 0.1)

「CARRIERをARR_DELAYとDEP_DELAYから予測する」という数式で多項ロジスティック回帰モデルを作成します。データの10%をテストデータとして使用します。以下のような結果を返します：

source_data model .test_index
source dataframe multinom model c(1)

作成されたモデルの要約情報を取得するにはmodel_coefまたはmodel_stats関数を使用できます。また、予測を行うにはprediction関数を使用できます。

build_coxph

概要
生存分析のためのCox比例ハザードモデルを作成し、データフレームに格納します。

シンタックス
build_coxph(<数式>, test_rate = <数値>, subset = <数値ベクトル>, weights = <数値ベクトル>, na.action = <NA処理方法>, init = <数値>, ties = <coxphのタイの処理方法>, singular.ok = <論理値>, model = <論理値>, x = <論理値>, y = <論理値>, tt = <関数>)

引数

例

元のデータ:

time status age sex
40 2 55 female
30 2 68 male
35 1 59 male
8 1 80 female

build_coxph(survival::Surv(time, status) ~ age + sex)

年齢(age)と性別(sex)に基づいて、対象者の生存を推定するCox比例ハザードモデルを作成します。モデルは返されるデータフレームに格納されます。作成されたモデルの要約情報を取得するにはmodel_coefまたはmodel_stats関数を使用できます。また、予測を行うにはprediction_coxph関数を使用できます。

prediction

概要
モデルについての回帰情報を含むデータフレームを返します。

シンタックス
prediction(data = "training"|"test"|"newdata", data_frame = <データセット>)

引数 * data (オプショナル) - デフォルトは"training"です。予測に使用するデータの種類を指定します。 * data_frame (オプショナル) - data="newdata"の場合のみ有効です。モデルを適用する別のデータフレームを指定します。

返り値
Data frame

例

元のデータ: モデルを含むデータフレーム

prediction(data = "test")

予測値を含むデータフレームを返します。

prediction_binary

概要
モデルについての二値分類情報を含むデータフレームを返します。

シンタックス
prediction_binary(<予測確率列>, <実測値列>, data = "training"|"test"|"newdata", threshold = <二値分類のメトリクス>, data_frame = <データセット>)

引数

返り値
Data frame

例

元のデータ: 二値分類モデルを含むデータフレーム

prediction_binary(data = "test", threshold = 0.2)

二値分類の予測値を含むデータフレームを返します。

prediction_coxph

概要
Cox比例ハザードモデルの予測値を含むデータフレームを返します。

シンタックス
prediction_coxph(data = "training"|"test", type.predict = <coxph予測タイプ>, type.residuals = <coxph残差タイプ>)

引数 * data (オプショナル) - デフォルトは"training"です。予測に使用するデータの種類を指定します。 * type.predict (オプショナル) - デフォルトは"lp"です。予測のタイプを以下から選択できます： * "lp" - 線形予測子 * "risk" - リスク * "expected" - 期待値 * type.residuals (オプショナル) - デフォルトは"martingale"です。残差のタイプを以下から選択できます： * "martingale" - マルチンゲール残差 * "deviance" - 偏差残差 * "score" - スコア残差 * "schoenfeld" - ショーンフェルド残差 * "scaledsch" - スケール調整済みショーンフェルド残差 * "dfbeta" - DFBETAの影響度診断 * "dfbetas" - 標準化されたDFBETAの影響度診断

返り値
Data frame

例

元のデータ: coxphモデルを含むデータフレーム

prediction_coxph(data = "test")

予測値を含むデータフレームを返します。

model_coef

概要
モデルの「パラメータ推定（係数）」に関する以下の情報を含むデータフレームを返します。

シンタックス
model_coef(conf_int = <信頼区間タイプ>, conf.level = <数値>)

引数

返り値
Data frame

例

元のデータ: lmモデルまたはglmモデル

model_coef(conf_int = "default", conf.level = 0.90)

「パラメータ推定」の情報を含むデータフレームを返します。

model_stats

概要
モデルについての「フィット概要」情報を含むデータフレームを返します。返される情報には以下が含まれます。

シンタックス
model_stats()

例

元のデータ（例: lm のモデルやglm のモデル）:

model_stats() 構築したモデルに対して、モデルの制度に関するサマリ情報を含むデータフレームを返します。

返り値
Data Frame

model_anova

概要
モデルについての分散分析（ANOVA）の検定情報を含むデータフレームを返します。返される情報には以下が含まれます。

シンタックス
model_anova()

返り値 Data Frame

例

model_anova() ANOVA（分散分析）の情報を含むデータフレームを返します。

evaluate_regression

回帰モデルの評価スコアを含むデータフレームを返します。含まれる指標は以下の通りです。

シンタックス
evaluate_regression(<予測値の列>, <実測値の列>)

引数

返り値 Data Frame

例

元のデータ:

到着遅延 予測値
10 7
20 30
-5 0
20 20
-5 3
10 8

evaluate_regression(予測値, 到着遅延) 回帰モデルの各種評価指標を含むデータフレームを返します。

evaluate_binary

概要
二値分類のモデルの評価を含むデータフレームを返します。含まれる指標は以下の通りです。

シンタックス
evaluate_binary(<予測確率の列>, <実測値の列>, threshold = <閾値または指標>)

引数

返り値 Data Frame

例

元のデータ:

遅延フラグ 予測確率
TRUE 0.82
TRUE 0.67
FALSE 0.34
TRUE 0.98
FALSE 0.19
TRUE 0.26

evaluate_binary(予測確率, 遅延フラグ, threshold = "accuracy") 二値分類のモデルの評価を含むデータフレームを返します。

evaluate_multi

概要
多クラス分類のモデルの評価を含むデータフレームを返します。含まれる指標は以下の通りです。

シンタックス
evaluate_multi(<予測ラベルの列>, <実測値の列>)

引数

返り値 Data Frame

例

元のデータ:

航空会社 予測ラベル
AA AA
9E 9E
AS AA
9E 9E
AA AA
AS FL

evaluate_multi(予測ラベル, 航空会社) 多クラス分類の評価を含むデータフレームを返します。

micro_f_score macro_f_score accuracy misclassification_rate
0.6666667 0.45 0.6666667 0.3333333

do_roc

概要
ROCカーブの座標を返します。ROC（Receiver Operating Characteristic）カーブは、二値分類のモデルの精度を評価するための曲線で、閾値の変更に伴う真陽性率と偽陽性率を可視化したものです。

シンタックス
do_roc(<予測確率の列>, <実測値の列>)

引数

返り値 Data Frame

例

元のデータ:

遅延フラグ 予測確率
TRUE 0.82
TRUE 0.67
FALSE 0.34
TRUE 0.98
FALSE 0.19
TRUE 0.26

do_roc(予測確率, 遅延フラグ) 真陽性率と偽陽性率を含むデータフレームを返します。これらの値はROCカーブを可視化するために利用できます。

true_positive_rate false_positive_rate
0.00 0.0
0.25 0.0
0.50 0.0
0.75 0.0
0.75 0.5
1.00 0.5
1.00 1.0

このデータを使用して、ラインチャートのX軸に「false_positive_rate」、Y軸に「true_positive_rate」を配置することでROCカーブを描画できます。

build_kmeans.cols

概要
K-Meansクラスタリングのモデルを構築し、モデルの要約または拡張されたデータを返します。

シンタックス
build_kmeans.cols(<列名>, centers = <整数>, fill = <数値>, fun.aggregate = <集計関数>, seed = <整数>, iter.max = <整数>, nstart = <整数>, algorithm = <kmeans_アルゴリズム>, trace = <論理値>, normalize_data = <論理値>, augment = <論理値>, keep.source = <論理値>)

引数

返り値 Data Frame

例

元のデータ:

地域 1900 1901 1902
Als 35.02899 24.02899 45.02899
Bea 18.00000 10.00000 27.00000
Bor 18.14896 10.64896 20.64896

build_kmeans.cols(-地域, centers=2, augment=TRUE) 「地域」列以外のすべての列を選択し、クラスター数を2に設定してK-meansクラスタリングのモデルを構築し、クラスター列を返します。モデルを評価したい場合は'augment'をFALSEに設定します。

地域 1900 1901 1902 .cluster
Als 35.02899 24.02899 45.02899 2
Bea 18.00000 10.00000 27.00000 1
Bor 18.14896 10.64896 20.64896 1

build_kmeans.kv

概要
K-Meansクラスタリングのモデルを構築し、生成されたデータフレームにモデルを格納、またはクラスターIDで元のデータを拡張します。

シンタックス
build_kmeans.kv(<列名>, <キー列>, <値列>, centers = <整数>, seed = <整数>, iter.max = <整数>, nstart = <整数>, algorithm = <kmeans_アルゴリズム>, trace = <論理値>, normalize_data = <論理値>, augment = <論理値>, keep.source = <論理値>)

引数

返り値 Data Frame

例

元のデータ:

地域 年 収穫日
Als 1900 35.02899
Als 1901 24.02899
Als 1902 45.02899
Bea 1900 18.00000
Bea 1901 10.00000
Bea 1902 27.00000
Bor 1900 18.14896
Bor 1901 10.64896
Bor 1902 20.64896

build_kmeans.kv(地域, 年, 収穫日, centers=2, augment=TRUE) クラスタリングする対象として「地域」、次元として「年」、値として「収穫日」を選択し、クラスター数を2に設定してK-meansクラスタリングモデルを構築し、クラスターの列を追加します。モデルを評価したい場合は'augment'をFALSEに設定します。

地域 年 収穫日 .cluster
Als 1900 35.02899 2
Als 1901 24.02899 2
Als 1902 45.02899 2
Bea 1900 18.00000 1
Bea 1901 10.00000 1
Bea 1902 27.00000 1
Bor 1900 18.14896 1
Bor 1901 10.64896 1
Bor 1902 20.64896 1

build_kmeans

概要
K-Meansクラスタリングのモデルを構築します。モデルは生成されたデータフレームに格納されるか、パラメータ値に応じて元のデータに追加されます。

シンタックス
build_kmeans(<列>, skv = <文字列ベクトル>, fill = <数値>, fun.aggregate = <集計関数>, centers = <整数>, iter.max = <整数>, nstart = <整数>, algorithm = <kmeans_アルゴリズム>, trace = <論理値>, normalize_data = <論理値>, seed = <整数>, augment = <論理値>, keep.source = <論理値>)

引数

返り値
Data frame（データフレーム）

例

元のデータ:

location 1900 1901 1902
Als 35.02899 24.02899 45.02899
Bea 18.00000 10.00000 27.00000
Bor 18.14896 10.64896 20.64896

build_kmeans(-location, centers=2) location列以外のすべての列を選択し、2をクラスター数として設定してK-meansクラスタリングを実行し、元のデータにクラスターの情報を追加します。

location X1900 X1901 X1902 cluster
Als 35.02899 24.02899 45.02899 2
Bea 18.00000 10.00000 27.00000 1
Bor 18.14896 10.64896 20.64896 1

元のデータ:

location year harvest_date
Als 1900 35.02899
Als 1901 24.02899
Als 1902 45.02899
Bea 1900 18.00000
Bea 1901 10.00000
Bea 1902 27.00000
Bor 1900 18.14896
Bor 1901 10.64896
Bor 1902 20.64896

build_kmeans(skv = c("location", "year", "harvest_date"), centers = 2) クラスタリングする対象として「location」、次元として「year」、値として「harvest_date」を選択し、クラスター数を2として設定してK-meansクラスタリングモデルを実行し、元のデータにクラスターの列を追加します。

location year harvest_date cluster
Als 1900 35.02899 2
Als 1901 24.02899 2
Als 1902 45.02899 2
Bea 1900 18.00000 1
Bea 1901 10.00000 1
Bea 1902 27.00000 1
Bor 1900 18.14896 1
Bor 1901 10.64896 1
Bor 1902 20.64896 1

do_t.test

概要
t検定を実行し、変数の平均値の差を検証します。

シンタックス
do_t.test(<値の列>, <グループの列>, alternative = <片側・両側検定の指定>, mu = <指定値>, paired = <論理値>, var.equal = <論理値>, conf.level = <数値>, subset = <論理列>, na.action = <欠損値の処理方法>)

引数

返り値 Data Frame

例

元のデータ:

地域 年 収穫量
Als 1900 35.02899
Als 1901 24.02899
Als 1902 45.02899
Bor 1900 18.14896
Bor 1901 10.64896
Bor 1902 20.64896

do_t.test(収穫量, 地域) t検定の結果を1行のデータフレームとして返します。

effect_size mean1 mean2 t.value p.value degrees_of_freedom conf.low conf.high method alternative
18.21336 34.69566 16.4823 3.1245 0.0356 4 1.8693 34.5574 Welch Two Sample t-test two.sided

do_var.test

概要
F検定を実行し、グループ間の分散の差を検証します。

シンタックス
do_var.test(<値の列>, <グループの列>, ratio = <数値>, alternative = <片側・両側検定の指定>, conf.level = <数値>, na.action = <欠損値の処理方法>)

引数

返り値 Data Frame

例

元のデータ:

地域 年 収穫量
Als 1900 35.02899
Als 1901 24.02899
Als 1902 45.02899
Bor 1900 18.14896
Bor 1901 10.64896
Bor 1902 20.64896

do_var.test(収穫量, 地域) F検定の結果を1行のデータフレームとして返します。

variance_ratio numerator_degrees_of_freedom denominator_degrees_of_freedom f.value p.value conf.low conf.high method alternative
2.614837 2 2 2.614837 0.3273 0.1311121 52.12883 F test to compare two variances two.sided

do_chisq.test

概要
カイ二乗分割表検定と適合度検定を実行します。

シンタックス
do_chisq.test(<列名>, correct = <論理値>, p = <数値列>, rescale.p = <論理値>, simulate.p.value = <論理値>, B = <数値>)

引数

返り値 Data Frame

例

元のデータ:

clarity GIA HRD IGI
IF 6 4 34
VS1 61 13 7
VS2 36 15 2
VVS1 15 23 14
VVS2 33 24 21

do_chisq.test(-clarity) clarity列を除くすべての列に対してカイ二乗検定を実行し、1行のデータフレームを返します。

statistic p.value parameter method
112.7472 0 8 Pearson's Chi-squared test

do_apriori

概要
トランザクションデータから同時に発生する傾向のあるアイテムのルールを見つけます。これは主に購買データの分析やアソシエーション分析に使用され、「どの商品が一緒に購入される傾向があるか」などのインサイトを得られます。

シンタックス
do_apriori(<列名>, <キー列>, minlen = <整数>, maxlen = <整数>, min_support = <数値>, max_support = <数値>, min_confidence = <数値>, lhs = <文字列ベクトル>, rhs = <文字列ベクトル>, max_basket_items = <数値>)

引数

返り値
Data Frame

Example

元のデータ:

商品名 注文ID
バナナ 1
リンゴ 1
ニンジン 2
リンゴ 2
オレンジ 3
ニンジン 3
リンゴ 4
ニンジン 4

do_apriori(商品名, 注文ID) 商品名に関する関連ルールを返します。

lhs rhs support confidence lift
リンゴ 0.75 0.7500000 1.0000000
ニンジン 0.75 0.7500000 1.0000000
バナナ リンゴ 0.25 1.0000000 1.3333333
オレンジ ニンジン 0.25 1.0000000 1.3333333
リンゴ ニンジン 0.50 0.6666667 0.8888889
ニンジン リンゴ 0.50 0.6666667 0.8888889

do_apriori(商品名, 注文ID, minlen=2) lhsとrhsのアイテム名の合計が2以上であるアソシエーションルールを返します。

lhs rhs support confidence lift
バナナ リンゴ 0.25 1.0000000 1.3333333
オレンジ ニンジン 0.25 1.0000000 1.3333333
リンゴ ニンジン 0.50 0.6666667 0.8888889
ニンジン リンゴ 0.50 0.6666667 0.8888889

do_apriori(商品名, 注文ID, lhs=c("リンゴ", "オレンジ")) リンゴまたはオレンジがlhs（左辺）に来るアソシエーションルールを返します。

lhs rhs support confidence lift
オレンジ ニンジン 0.25 1.0000000 1.3333333
リンゴ ニンジン 0.50 0.6666667 0.8888889

do_anomaly_detection

概要
時系列データの異常値を検出します。

シンタックス
do_anomaly_detection(<日付列>, <数値列>, direction = <anomaly_direction_type>, e_value = <logical>, max_anoms = <numeric>, alpha = <numeric>, only_last = <anomaly_last_type>, threshold = <anomaly_threshold_type>, longterm = <logical>, piecewise_median_period_weeks = <integer>)

引数

返り値
Data frame

例

元のデータ:

日時 新規ユーザー
2017-01-20 09:00:00 4
2017-01-20 10:00:00 2
2017-01-20 11:00:00 5
2017-01-20 12:00:00 31
2017-01-20 13:00:00 3
2017-01-20 14:00:00 3

do_anomaly_detection(日時, 新規ユーザー, direction = "both", e_value = TRUE) 異常値に関する情報を含む列を持つデータフレームを返します。

日時 新規ユーザー pos_anomaly pos_value neg_anomaly neg_value expected_value
2017-01-20 09:00:00 4 FALSE NA FALSE NA 4
2017-01-20 10:00:00 2 FALSE NA FALSE NA 2
2017-01-20 11:00:00 5 FALSE NA FALSE NA 5
2017-01-20 12:00:00 31 TRUE 31 FALSE NA 5
2017-01-20 13:00:00 3 FALSE NA FALSE NA 3
2017-01-20 14:00:00 3 FALSE NA FALSE NA 3

do_prophet

概要
時系列のデータフレームに予測値を追加します。Facebook開発のProphetアルゴリズムを使用して将来のトレンドを予測します。

シンタックス
do_prophet(<日付列>, <数値列>, <数値>, time_unit = <prophet_time_unit>, include_history = <logical>, fun.aggregate = <aggregate_function>, growth = "linear"|"logistics", seasonality.prior.scale = <numeric>, yearly.seasonality = <logical>, weekly.seasonality = <logical>, n.changepoints = <numeric>, changepoint.prior.scale = <numeric>, changepoints = <list>, holidays.prior.scale = <numeric>, holidays = <data_set>, mcmc.samples = , interval.width = , uncertainty.samples = )

引数

返り値
Data frame

Return Value
Data frame

例

元のデータ:

日付 ページビュー
2017-03-19 2383
2017-03-20 4441
2017-03-21 3147
2017-03-22 456

do_prophet(日付, ページビュー, 2, time_unit = "day") 2日分の予測値の行と、トレンドや季節性に関する列を持つデータフレームを返します。

日付 ページビュー forecasted_value forcasted_value_high forcasted_value_low trend trend_high trend_low seasonal seasonal_low seasonal_high yearly yearly_low yearly_high weekly weekly_low weekly_high
2017-03-19 2383 3200.6539 4150.7993 2199.57 1131.882 1131.882 1131.882 2068.7719 2068.7719 2068.7719 1014.3165 1014.3165 1014.3165 -177.1076 -177.1076 -177.1076
2017-03-20 4441 3401.953 4330.5388 2401.9095 1089.3266 1089.3266 1089.3266 2312.6264 2312.6264 2312.6264 1258.171 1258.171 1258.171 -174.3324 -174.3324 -174.3324
2017-03-21 3147 2723.3344 3655.037 1841.2349 1046.7712 1046.7712 1046.7712 1676.5631 1676.5631 1676.5631 622.1077 622.1077 622.1077 15.2078 15.2078 15.2078
2017-03-22 456 1209.1918 2152.4326 298.3122 1004.2159 1004.2159 1004.2159 204.976 204.976 204.976 -849.4794 -849.4794 -849.4794 143.4983 143.4983 143.4983
2017-03-23 NA 654.9152 1581.3289 -276.3799 876.5498 876.5498 876.5497 -221.6346 -221.6346 -221.6346 -1276.09 -1276.09 -1276.09 107.7315 107.7315 107.7315
2017-03-24 NA 2090.3595 3049.9388 1133.799 833.9944 833.9944 833.9944 1256.3651 1256.3651 1256.3651 201.9097 201.9097 201.9097 77.2003 77.2003 77.2003

do_market_impact

概要
合成対照群（synthetic control）を形成するために他の市場を使用して、市場にイベント（広告など）の影響を推定します。これは、特定の市場で行われた介入（マーケティングキャンペーンなど）の効果を分析するのに役立ちます。

シンタックス
do_market_impact(<日付列>, <数値列>, <テキスト列>, target_market = <text>, time_unit = <market_impact_time_unit>, fun.aggregate = <aggregate_function>, event_time = <text>, output_type = "series"|"model_stats"|"model_coef"|"predictor_market_candidates", na_fill_type = "spline"|"interpolate"|"previous"|"value", na_fill_value = <numeric>, distance_weight = <numeric>, alpha = <numeric>, niter = <numeric>, standardize.data = <logical>, prior.level.sd = <numeric>, nseasons = <numeric>, season.duration = <numeric>, dynamic.regression = <logical>)

引数

返り値
Data frame

例

元のデータ:

日付 ページビュー 国
2017-03-19 2383 日本
2017-03-19 3625 イギリス
2017-03-19 3825 アメリカ
2017-03-20 4441 日本
2017-03-20 4721 イギリス
2017-03-20 8367 アメリカ
2017-03-21 383 日本
2017-03-21 2693 イギリス
2017-03-21 3147 アメリカ

do_market_impact(日付, ページビュー, 国, target_market = "日本", event_time = "2017-03-20") ターゲット市場のページビュー、他の市場のページビューから計算された合成対照、およびターゲット市場にのみ発生したイベント（広告など）の推定影響を含むデータフレームを返します。

出力データフレームの列:

row_as_header

概要
指定した行を列名として使用します。

シンタックス
row_as_header(row_index = <整数値>, prefix = <文字列>, clean_names = <TRUE|FALSE>)

引数

返り値
Data frame

例

Original data:

V1 V2
NA NA
item.name transaction.id
banana 1
apple 1
carrot 2
apple 2
orange 3
carrot 3
apple 4
carrot 4

row_as_header(row_index = 2, prefix = "c_", clean_names = TRUE) 2行目を列名として使用し、接頭辞を付けてドットをアンダースコアに置き換えた列名のデータフレームを返します。

c_item_name c_transaction_id
NA NA
banana 1
apple 1
carrot 2
apple 2
orange 3
carrot 3
apple 4
carrot 4

row_as_header(row_index = -1, prefix = "", clean_names = TRUE) 最後の行を列名として使用したデータフレームを返します。

carrot 4
NA NA
item.name transaction.id
banana 1
apple 1
carrot 2
apple 2
orange 3
carrot 3
apple 4

pivot

概要
行と列にピボットします。値は行と列のペアの数や、別の列の集計です。データの再構成やクロス集計表を作成する際に便利です。

シンタックス
pivot(<formula>, value = <column>, fill = <numeric>, fun.aggregate = <character>, na.rm = <logical>)

引数

返り値
Data frame

例

元のデータ:

透明度 認証 色 価格
VVS2 HRD F 10796
VS1 GIA F 1551
VS1 GIA F 4291
VVS2 GIA F 5881
VS2 GIA H 4585
VVS2 GIA H 5193

pivot(透明度+色~認証, value = 価格, fill=0, fun.aggregate = sum) 透明度と色の組み合わせを行とし、認証を列とするデータフレームを返します。値は価格の合計であり、欠損値は0で埋められます。

透明度_色 GIA HRD
VS1_F 5842 0
VS2_H 4585 0
VVS2_F 5881 10796
VVS2_H 5193 0

元のデータ:

運航日 到着遅延 航空会社
2018-10-01 10 AA
2018-10-02 20 UA
2018-10-03 30 AA
2018-10-04 40 UA
2018-11-01 20 UA
2018-11-02 10 AA
2018-11-03 20 UA
2018-11-04 30 AA

pivot(floor_date(運航日, unit="month") ~ 航空会社, value = 到着遅延, fun.aggregate = mean) 月単位に切り捨てた運航日を行、各航空会社を列とするデータフレームを返します。値は到着遅延の平均です。

運航日 AA UA
2018-10-01 20 30
2018-11-01 20 20

do_cor.cols

概要
すべての変数（列）のペアの相関を計算します。

シンタックス
do_cor.cols(<列名>, use = <cor_na_operation>, method = <cor_method>, distinct = <logical>, diag = <logical>)

引数

返り値
Data frame

例

元のデータ:

年 Als Bea Bor
1900 35.02899 18 18.14896
1901 24.02899 10 10.64896
1902 45.02899 27 20.64896

do_cor.cols(-年) 年の列を除くすべての列のペアの相関を計算して返します。

pair.name.1 pair.name.2 value
Als Bea 0.9981135
Als Bor 0.9680283
Bea Als 0.9981135
Bea Bor 0.9508014
Bor Als 0.9680283
Bor Bea 0.9508014

do_cor.kv

概要
選択列の全てのペアの組み合わせの相関係数を計算します。

シンタックス
do_cor.kv(<列名>, <キー列>, <値列>, use = <欠損値処理方法>, method = <相関計算方法>, distinct = <論理値>, diag = <論理値>, fill = <数値>, fun.aggregate = <集計関数>)

引数

返り値
Data Frame

例

元のデータ:

位置 年 収穫日
地点A 1900 35.02899
地点A 1901 24.02899
地点A 1902 45.02899
地点B 1900 18.00000
地点B 1901 10.00000
地点B 1902 27.00000
地点C 1900 18.14896
地点C 1901 10.64896
地点C 1902 20.64896

do_cor.kv(位置, 年, 収穫日)

位置ごとの年別収穫日のデータに基づいて相関係数を計算します。

位置.x 位置.y value
地点A 地点B 0.9981135
地点A 地点C 0.9680283
地点B 地点A 0.9981135
地点B 地点C 0.9508014
地点C 地点A 0.9680283
地点C 地点B 0.9508014

do_cor

概要
選択した変数の値のペアについて相関係数を計算します。

シンタックス
do_cor(<列名>, skv = <文字列ベクトル>, use = <欠損値処理方法>, method = <相関計算方法>, distinct = <論理値>, diag = <論理値>, fill = <数値>, fun.aggregate = <集計関数>)

引数

返り値
Data Frame

例

元のデータ:

年 地点A 地点B 地点C
1900 35.02899 18 18.14896
1901 24.02899 10 10.64896
1902 45.02899 27 20.64896

do_cor(-年)

年を除く全ての列（地点A、地点B、地点C）の間の相関係数を計算します。

pair.name.1 pair.name.2 value
地点A 地点B 0.9981135
地点A 地点C 0.9680283
地点B 地点A 0.9981135
地点B 地点C 0.9508014
地点C 地点A 0.9680283
地点C 地点B 0.9508014

元のデータ:

位置 年 収穫日
地点A 1900 35.02899
地点A 1901 24.02899
地点A 1902 45.02899
地点B 1900 18.00000
地点B 1901 10.00000
地点B 1902 27.00000
地点C 1900 18.14896
地点C 1901 10.64896
地点C 1902 20.64896

do_cor(skv = c("位置", "年", "収穫日"))

年をキー、収穫日を値として、位置間の相関係数を計算します。

位置.x 位置.y value
地点A 地点B 0.9981135
地点A 地点C 0.9680283
地点B 地点A 0.9981135
地点B 地点C 0.9508014
地点C 地点A 0.9680283
地点C 地点B 0.9508014

do_dist.kv

概要
各ペア間の距離を計算します。キー列を次元、値列を値として使用し、様々な距離計算手法から選択できます。

シンタックス
do_dist.kv(<列名>, <キー列>, <値列>, distinct = <論理値>, diag = <論理値>, method = <距離計算方法>, fill = <数値>, fun.aggregate = <集計関数>, p = <数値>)

引数

返り値
Data Frame

例

元のデータ:

日付 名前 商品 数量
2015-06-12 佐藤 オレンジ 5
2015-06-12 田中 りんご 3
2015-06-12 鈴木 にんじん 3
2015-06-13 田中 りんご 4
2015-06-13 鈴木 りんご 6
2015-06-16 佐藤 オレンジ 2
2015-06-16 鈴木 にんじん 4
2015-06-16 田中 オレンジ 7

do_dist.kv(名前, 商品, 数量) このデータからは以下のような行列が考慮されます。重複する項目はデフォルトで平均値で集計されます。fun.aggregate引数で変更できます。

田中 鈴木 佐藤
りんご 3.5 6.0 0.0
にんじん 0.0 3.5 0.0
オレンジ 7.0 0.0 3.5

最終的に以下のような各列のペア間のユークリッド距離を計算します。

名前.x 名前.y value
田中 鈴木 8.215838
田中 佐藤 4.949747
鈴木 田中 8.215838
鈴木 佐藤 7.778175
佐藤 田中 4.949747
佐藤 鈴木 7.778175

do_dist.kv(名前, 商品, 数量, fun.aggregate=sum, method="manhattan") このデータからは以下のような行列が考慮されます。重複する項目は合計で集計されます。

田中 鈴木 佐藤
りんご 7 6 0
にんじん 0 7 0
オレンジ 7 0 7

最終的に以下のような各列のペア間のマンハッタン距離を計算します。

名前.x 名前.y value
田中 鈴木 15
田中 佐藤 7
鈴木 田中 15
鈴木 佐藤 20
佐藤 田中 7
佐藤 鈴木 20

do_dist.cols

概要
各ペア間の距離を計算します。列をベクトルとして扱い、指定した距離計算手法に基づいて列間の距離を算出します。

シンタックス
do_dist.cols(<列名>, distinct = <論理値>, diag = <論理値>, method = <距離計算方法>, p = <数値>)

引数

返り値
Data Frame

例

元のデータ:

年 地点A 地点B 地点C
1900 35.02899 18 18.14896
1901 24.02899 10 10.64896
1902 45.02899 27 20.64896

do_dist.cols(-年)

年を除く全ての列（地点A、地点B、地点C）の間の距離を計算します。

pair.name.1 pair.name.2 value
地点A 地点B 28.492868
地点A 地点C 32.532238
地点B 地点A 28.492868
地点B 地点C 6.385847
地点C 地点A 32.532238
地点C 地点B 6.385847

do_dist

概要
指定した変数の全てのペアについて距離を計算します。

シンタックス
do_dist(<列名>, skv = <文字列ベクトル>, distinct = <論理値>, diag = <論理値>, method = <距離計算方法>, p = <数値>, fill = <数値>, fun.aggregate = <集計関数>)

引数

返り値
Data Frame

元のデータ:

year Als Bea Bor
1900 35.02899 18 18.14896
1901 24.02899 10 10.64896
1902 45.02899 27 20.64896

do_dist(-year) year列を除く列（Als、Bea、Bor）の間の距離を計算します。

pair.name.1 pair.name.2 value
Als Bea 28.492868
Als Bor 32.532238
Bea Als 28.492868
Bea Bor 6.385847
Bor Als 32.532238
Bor Bea 6.385847

元のデータ:

date name product num
2015-06-12 Lisa orange 5
2015-06-12 Emily apple 3
2015-06-12 John carrot 3
2015-06-13 Emily apple 4
2015-06-13 John apple 6
2015-06-16 Lisa orange 2
2015-06-16 John carrot 4
2015-06-16 Emily orange 7

do_dist(skv = c("name", "product", "num"))

このデータからは以下のような行列が考慮されます。重複する項目はデフォルトで平均値で集計されます。

Emily John Lisa
apple 3.5 6.0 0.0
carrot 0.0 3.5 0.0
orange 7.0 0.0 3.5

そして、各列のペア間のユークリッド距離を計算します。

name.x name.y value
Emily John 8.215838
Emily Lisa 4.949747
John Emily 8.215838
John Lisa 7.778175
Lisa Emily 4.949747
Lisa John 7.778175

do_dist(skv = c("location", "year", "harvest_date"), fun.aggregate=sum, method="manhattan")

このデータからは以下のような行列が考慮されます。重複する項目は合計で集計されます。

Emily John Lisa
apple 7 6 0
carrot 0 7 0
orange 7 0 7

そして、各列のペア間のマンハッタン距離を計算します。

name.x name.y value
Emily John 15
Emily Lisa 7
John Emily 15
John Lisa 20
Lisa Emily 7
Lisa John 20

str_remove_before

概要
指定した区切り文字または正規表現に一致する箇所より前の文字列を取り除きます。

シンタックス
str_remove_before(<テキストの列>, sep = <区切り文字>, include_sep = <TRUE|FALSE>)

引数

返り値
Character

例
str_remove_before(X1, sep = ",") X1列からカンマより前の文字列をカンマも含めて削除します。

X1 NEW
New York, USA USA
Tokyo, Japan Japan
Paris, France France

str_remove_before(X1, sep = ",", include_sep = FALSE) X1列からカンマより前の文字列を削除しますが、カンマは残します。

X1 NEW
New York, USA , USA
Tokyo, Japan , Japan
Paris, France , France

str_remove_after

概要
指定した区切り文字または正規表現に一致する箇所より後ろの文字列を取り除きます。

シンタックス
str_remove_after(<テキストの列>, sep = <区切り文字>, include_sep = <TRUE|FALSE>)

引数

返り値
Character

例
str_remove_after(X1, sep = ",") X1列からカンマより後ろの文字列をカンマも含めて削除します。

X1 NEW
New York, USA New York
Tokyo, Japan Tokyo
Paris, France Paris

str_remove_after(X1, sep = ",", include_sep = FALSE) X1列からカンマより後ろの文字列を削除しますが、カンマは残します。

X1 NEW
New York, USA New York,
Tokyo, Japan Tokyo,
Paris, France Paris,

str_remove_range

概要
テキストデータから指定した範囲の文字を取り除きます。

シンタックス
str_remove_range(<テキストの列>, start = <開始位置>``, end =<終了位置>```)

引数

返り値
Character

例 str_remove_range(X1, start = 1, end = 3) X1列から1文字目から3文字目までの文字を削除します。

X1 NEW
Hello lo
World ld
データ分析 析

str_remove_range(X1, start = -3) X1列から末尾3文字を削除します。

X1 NEW
Hello He
World Wo
データ分析 データ

str_replace_before

概要
指定した区切り文字または正規表現に一致する箇所より前の文字列を、指定した文字列に置き換えます。

シンタックス
str_replace_before(<テキストの列>, sep = <区切り文字>, rep = <置換する文字列>, include_sep = <TRUE|FALSE>)

引数

返り値
Character

例
str_replace_before(X1, sep = ",", rep = "City") X1列のカンマより前の文字列を"City"に置換します。

X1 NEW
New York, USA City USA
Tokyo, Japan City Japan
Paris, France City France

str_replace_before(X1, sep = ",", rep = "City", include_sep = FALSE) X1列のカンマより前の文字列を"City"に置換しますが、カンマは残します。

X1 NEW
New York, USA City, USA
Tokyo, Japan City, Japan
Paris, France City, France

str_replace_after

概要
指定した区切り文字または正規表現に一致する箇所より後ろの文字列を、指定した文字列に置き換えます。

シンタックス
str_replace_after(<テキストの列>, sep = <区切り文字>, rep = <置換する文字列>, include_sep = <TRUE|FALSE>)

引数

返り値
Character

例
str_replace_after(X1, sep = ",", rep = "Country") X1列のカンマより後ろの文字列を"Country"に置換します。

X1 NEW
New York, USA New York Country
Tokyo, Japan Tokyo Country
Paris, France Paris Country

str_replace_after(X1, sep = ",", rep = "Country", include_sep = FALSE) X1列のカンマより後ろの文字列を"Country"に置換しますが、カンマは残します。

X1 NEW
New York, USA New York, Country
Tokyo, Japan Tokyo, Country
Paris, France Paris, Country

str_replace_range

概要
テキストデータの指定した範囲の文字を、別の文字列に置き換えます。

シンタックス
str_replace_range(<テキストの列>, start = <開始位置>, end = <終了位置>, replacement = <置換する文字列>)

引数

返り値
Character

例 str_replace_range(X1, start = 1, end = 3, replacement = "NEW") X1列の1文字目から3文字目までの文字を"NEW"に置換します。

X1 NEW
Hello NEWlo
World NEWld
データ分析 NEW析

str_replace_range(X1, start = -3, replacement = "END") X1列の末尾3文字を"END"に置換します。

X1 NEW
Hello HeEND
World WoEND
データ分析 データEND

str_extract_before

概要
指定した区切り文字または正規表現に一致する箇所より前の文字列を抽出します。

シンタックス
str_extract_before(<テキストの列>, sep = <区切り文字>, include_sep = <TRUE|FALSE>)

引数

返り値
Character

例
str_extract_before(X1, sep = ",") X1列からカンマより前の文字列をカンマを除いて抽出します。

X1 NEW
New York, USA New York
Tokyo, Japan Tokyo
Paris, France Paris

str_extract_before(X1, sep = ",", include_sep = TRUE) X1列からカンマより前の文字列をカンマも含めて抽出します。

X1 NEW
New York, USA New York,
Tokyo, Japan Tokyo,
Paris, France Paris,

str_extract_after

概要
指定した区切り文字または正規表現に一致する箇所より後ろの文字列を抽出します。

シンタックス
str_extract_after(<テキストの列>, sep = <区切り文字>, include_sep = `<TRUE|FALSE>)

引数

返り値
Character

例
str_extract_after(X1, sep = ",") X1列からカンマより後ろの文字列をカンマを除いて抽出します。

X1 NEW
New York, USA USA
Tokyo, Japan Japan
Paris, France France

str_extract_after(X1, sep = ",", include_sep = TRUE) X1列からカンマより後ろの文字列をカンマも含めて抽出します。

X1 NEW
New York, USA , USA
Tokyo, Japan , Japan
Paris, France , France

str_extract_inside

概要
指定した文字や記号の中のテキストを抽出することができます。抽出される文字列が複数ある場合はlist型となるため、list_to_text関数で囲ってください。

シンタックス
str_extract_inside(<テキストの列>, begin = <文字列>, end = <文字列>, include_special_chars = <TRUE|FALSE>, all = <TRUE|FALSE>))

引数

返り値
Character

例
list_to_text(str_extract_inside(X1, begin = "(", end = ")", include_special_chars = FALSE, all = TRUE)) X1列の文字列から指定した"("と、")"の間にある内容を抽出します。

X1 NEW
Exploratory (San Francisco) San Francisco

list_to_text(str_extract_inside(X1, begin = "{", end = "}", include_special_chars = FALSE, all = TRUE)) X1列の文字列から指定した"{"と、"}"の間にある内容を抽出します。

X1 NEW
Google {Mountain View} Mountain View

list_to_text(str_extract_inside(X1, begin = "[", end = "]", include_special_chars = FALSE, all = TRUE)) X1列の文字列から指定した"["と、"]"の間にある内容を抽出します。

X1 NEW
Apple [Cupertino] Cupertino

list_to_text(str_extract_inside(X1, begin = "'", end = "'", include_special_chars = FALSE, all = TRUE)) X1列の文字列から指定した"'"と、"'"の間にある内容を抽出します。

X1 NEW
Facebook 'Menlo Park' Menlo Park

list_to_text(str_extract_inside(X1, begin = '"', end = '"', include_special_chars = FALSE, all = TRUE)) X1列の文字列から指定された指定した"""と、"""の間にある内容を抽出します。

X1 NEW
Amazon "Seattle" Seattle

str_clean

概要
エスケープ文字（例: \n, \t）、余分な空白、余分なピリオド、先頭と末尾のスペースを削除して、テキストをきれいにします。

シンタックス
str_clean(<文字列>)

引数

返り値
Character

例
str_clean(X1) X1列の文字列から不要な空白を削除します。

X1 NEW
" Exploratory .io " Exploratory.io
" Data .Science " Data.Science
" R .Studio " R.Studio

str_count_all

概要
文字列のパターンを数えます。

シンタックス
str_count_all(<テキストの列>, patterns = <文字列>, remove.zero = <TRUE|FALSE>)

引数

返り値
List of data frame

例
str_count_all(X1, patterns=c("apple", "banana"), remove.zero=TRUE) X1列の文字列内で指定されたパターン（appleとbanana）の出現回数をリストで返します。

X1 NEW
I ate banana, apple, and peach yesterday, and banana, peach today. list(.count = c(1, 2), .pattern = c("apple", "banana"))
I love eating banana and apple for breakfast, and banana for lunch. list(.count = c(1, 2), .pattern = c("apple", "banana"))
The store has apple juice and banana smoothie. list(.count = c(1, 1), .pattern = c("apple", "banana"))

str_normalize

概要
全角のアルファベット、数字、特殊文字を通常のアルファベット、数字、特殊文字に置き換えます。また半角カナ文字を全角カナ文字に置き換え、その他の正規化規則を適用してテキストを正規化します。これはUnicode 正規化形の規則に従います。なお、この関数はstringi::stri_trans_nfkc 関数のラッパー関数です。

シンタックス
str_normalize(<テキストの列>)

引数

返り値
Character

例
str_normalize(X1) X1列の全角文字を半角文字に正規化します。

X1 NEW
ＡＢＣ１２３＋ー＝ ABC123+-=
ＲＳｔｕｄｉｏ RStudio
１２３４５６ 123456

str_logical

概要
変換対象の列のデータタイプ（データ型）をロジカル型に変換します。 引数の"true_value"に指定がない場合、"true", "Yes", "yes", "1"をTRUEに変換し、"false", "No", "no", "0"をFALSEに変換します。 もし特定の値をTRUEにし、それ以外の値をFALSEにしたい場合は、true_valueにTRUEにしたい元の値を指定します。 また、ロジカル型への変換対象の列が大文字、小文字が混在していたとしても、大文字、小文字は無視して文字列のみに注目してロジカル型への変換が行われます。

シンタックス

str_logical(<ロジカル型への変換対象の列>, true_value = <TRUEにしたい値>)

引数

返り値
Logical

例

mutate(New = str_logical(`コンバージョン`)) コンバージョン列の Yes/No 形式の文字列をロジカル型に変換します。大文字と小文字は区別しません。

コンバージョン NEW
Yes TRUE
No FALSE
NA NA

mutate(New = str_logical(`返品`)) 返品列のtrue/false 形式の文字列をロジカル型に変換します。大文字と小文字は区別しません。

返品 NEW
true TRUE
false FALSE
NA NA

mutate(New = str_logical(`離職`)) 離職列の数値（1/0）をロジカル型に変換します。

離職 NEW
1 TRUE
0 FALSE
NA NA

mutate(New = str_logical(サインアップ, true_value = "Sign Up")) サインアップ列の指定した文字列である"Sign Up"をTRUEに、それ以外をFALSEとしてロジカル型に変換します。大文字と小文字は区別しません。

サインアップ New
Sign Up TRUE
Not Yet FALSE
NA NA

get_stopwords

概要
"a"、"the"、"and"などのストップワードを返します。

シンタックス
get_stopwords(lang = <言語>, include = <文字列のリスト>, exclude = <文字列のリスト>)

引数

返り値
Character

例

get_stopwords()
"a", "the", "and"といった値のリストを返します。

word_to_sentiment

概要
単語に対して、肯定的または否定的なセンチメントの種類を返します。

シンタックス
word_to_sentiment(<テキストの列>, lexicon = <感情辞書のタイプ>)

引数

返り値
引数lexiconに"bing" (デフォルト)を指定した場合はCharacter. 引数lexiconに"AFINN" を指定した場合はNumeric. 引数lexiconに"nrc" を指定した場合はList.

例
word_to_sentiment(X1) X1列の単語が、肯定的か、否定的かを文字列で返します。

X1 NEW
good positive
happy positive
bad negative

word_to_sentiment(X1, lexicon="AFINN") X1列の単語について、AFINNを使用して数値化した感情値を返します。

X1 NEW
bad -3
good 3
happy 2

word_to_sentiment(X1, lexicon="nrc") X1列の単語について、nrcを使用して感情カテゴリーのベクトルを返します。

X1 NEW
cry c("negative","sadness")
joy c("positive","joy")
love c("positive","joy")

get_sentiment

概要
文章からセンチメントスコアを返します。正のスコアは肯定的な文章を表し、負のスコアはその反対を表します。0は「中立」を意味します。

シンタックス
get_sentiment(<テキストの列>)

引数

返り値
Numeric

例
get_sentiment(X1) X1列の文章について、センチメントスコアを返します。正の値は肯定的な感情を、負の値は否定的な感情を示します。

X1 NEW
I'm happy 0.7071068
I'm sick -0.7071068
I'm not so good -0.5000000

stem_word

概要
綴りが若干異なる単語を同じ単語として認識できるように整えます。

シンタックス
stem_word(<テキストの列>, language = <言語>)

引数

返り値
Character

例
stem_word(X1) X1列の単語について、同じ単語として認識できるように整えます。

X1 NEW
stand stand
stands stand
cheerful cheer

is_stopword

概要
文字列に辞書で定義されたストップワードのリストに含まれる単語がある場合、TRUEを返します。

シンタックス
is_stopword(<テキストの列>, lang = <言語>, include = <文字列のリスト>, exclude = <文字列のリスト>)

引数

返り値
Logical

例
is_stopword(X1) X1列の単語について、ストップワードかどうかを判定して論理値（TRUEまたはFALSE）で返します。

X1 NEW
a TRUE
and TRUE
stopword FALSE

is_empty

概要
文字列が空文字または NAのときにTRUEを返します。

シンタックス
is_empty(<テキストの列>)

引数

返り値
Logical

例
is_empty(X1) X1列が空またはNAのときにTRUEを返します。

X1 NEW
Apple FALSE
TRUE
Cat FALSE

is_alphabet

概要
文字列がアルファベットのみを含む場合に TRUE を返します。

シンタックス
is_alphabet(<テキストの列>)

引数

返り値
Data frame

例
is_alphabet(X1) X1列の文字列について、アルファベットのみで構成されているかどうかを判定して論理値（TRUEまたはFALSE）で返します。なお、この関数はトークン（単語）に使用されることを想定しており、複数の単語で構成される文章に使用された場合はFALSEを返します。

X1 NEW
hello TRUE
Hello World FALSE
32MB FALSE

ip_to_country

概要
IPアドレスから国名を返します。

シンタックス
ip_to_country(<テキストの列>)

引数

返り値
Character

例
ip_to_country(X1) X1列のIPアドレスに対応する国名を返します。_

X1 NEW
133.43.96.45 Japan
172.217.0.46 USA
91.198.174.192 UK

url_domain

概要
url からドメイン (例: "exploratory.io")を返します。

シンタックス
url_domain(<テキストの列>)

引数

返り値
Character

例
url_domain(X1) X1列のURLについて、ドメイン部分を抽出して返します。

X1 NEW
https://exploratory.io/login/ exploratory.io
https://github.com/ github.com
https://www.google.com/ google.com

url_fragment

概要
url からフラグメントを返します。

シンタックス
url_fragment(<テキストの列>)

引数

返り値
Character

例
url_fragment(X1) X1列のURLについて、フラグメント部分（#以降）を抽出して返します。

X1 NEW
https://exploratory.io/?debug=true#test test
https://example.com/page#section1 section1
https://site.com/#bottom bottom

url_path

概要
urlからパスを返します。

シンタックス
url_path(<テキストの列>)

引数

返り値
Character

例

url_path(X1) X1列のURLについて、パス部分を抽出して返します。

X1 NEW
https://exploratory.io/reference/ reference/
https://example.com/docs/api/ docs/api/
https://site.com/blog/post1/ blog/post1/

url_port

概要
url からポートを返します。

シンタックス
url_port(<テキストの列>)

引数

返り値
Character

例
url_port(X1) X1列のURLについて、ポート番号を抽出して返します。

X1 NEW
https://exploratory.io:443 443
http://localhost:8080 8080
https://example.com:8443 8443

url_scheme

概要
urlからスキーム（例："http"、"https"）を返します。

シンタックス
url_scheme(<テキストの列>)

引数

返り値
Character

例
url_scheme(X1) X1列のURLについて、スキーマ部分（プロトコル）を抽出して返します。

X1 NEW
https://exploratory.io https
http://example.com http
ftp://files.example.com ftp

url_suffix

概要
urlから接尾辞（例："com"、"org"）を返します。

シンタックス
url_suffix(<テキストの列>)

引数

返り値
Character

例
url_suffix(X1) X1列のURLについて、ドメインのサフィックスを抽出して返します。

X1 NEW
https://exploratory.io io
http://sample.edu.co edu.co
https://example.com com

url_subdomain

概要
urlからサブドメイン (例 "www", "blog") を返します。

シンタックス
url_subdomain(<テキストの列>)

引数

返り値
Character

例
url_subdomain(X1) X1列のURLについて、サブドメイン部分を抽出して返します。

X1 NEW
https://blog.exploratory.io blog
https://dev.example.com dev
https://mail.google.com mail

url_tld

概要
url からトップレベルドメイン (例 "com"、"co") を返します。

シンタックス
url_tld(<テキストの列>)

引数

返り値
Character

例
url_tld(X1) X1列のURLについて、トップレベルドメインを抽出して返します。

X1 NEW
http://sample.edu.co co
https://example.com com
https://website.org org

url_param

概要

url からデコードされたクエリパラメーターを返します。

シンタックス
url_param(<テキストの列>, parameter_name = <文字列>)

引数

返り値
Character

例
url_param(X1, "user") X1列のURLから、指定したパラメータ（この場合は"user"）の値を抽出して返します。

X1 NEW
http://example.com/?user=ferret ferret
http://site.com/?user=john&type=admin john
http://app.com/?user=mary&id=123 mary

countrycode

概要
国名や国名コードを他の形式の国コードや名前（国名、大陸名、地域名など）に変換します。国際的なデータ分析やレポート作成時に、異なるデータソースの国コードを統一するのに役立ちます。

シンタックス
countrycode(<国名または国コードの列>, origin = <変換前の国コードまたは国名の形式>, destination = <変換後の国コードまたは国や地域名の形式>)

引数

originやdestinationで選択可能な引数の値:

返り値
変換後の国名、国コード、大陸名、または地域名（指定したdestinationの形式による）

例

countrycode(国名, origin = "country.name", destination = "iso2c")

国名列の国名を、ISO 3166-1 alpha-2（2文字の国コード）に変換します。略称や一般的な呼び名も自動的に認識されます。

国名 ISO2コード
U.S. US
United States US
Japan JP
China CN
South Korea KR

countrycode(ISO2コード, origin = "iso2c", destination = "country.name")

ISO2コード列の2文字の国コードを、正式な英語の国名に変換します。

ISO2コード 国名
US United States
JP Japan
GB United Kingdom
DE Germany
FR France

countrycode(COWコード, origin = "cowc", destination = "country.name")

COWコード列のCorrelates of Warの文字形式の国コードを、正式な英語の国名に変換します。

COWコード 国名
USA United States
JPN Japan
GBR United Kingdom
RUS Russia
CHN China

countrycode(COW数値コード, origin = "cown", destination = "country.name")

COW数値コード列のCorrelates of Warの数値コードを、正式な英語の国名に変換します。

COW数値コード 国名
2 United States
4 United Kingdom
81 Japan
365 Russia
710 China

countrycode(ISO3コード, origin = "iso3c", destination = "iso2c")

ISO3コード列の3文字の国コードを、2文字の国コードに変換します。

ISO3コード ISO2コード
USA US
JPN JP
GBR GB
DEU DE
FRA FR

countrycode(国名, origin = "country.name", destination = "continent")

国名列の国名を、その国が属する大陸名に変換します。

国名 大陸名
United States Americas
Japan Asia
Germany Europe
South Africa Africa
Australia Oceania

countrycode(国名, origin = "country.name", destination = "region")

国名列の国名を、7地域に分類した地域名に変換します。

国名 地域名
United States Northern America
Japan Eastern Asia
Germany Western Europe
Brazil South America
Australia Australia and New Zealand

statecode

概要

米国の州の情報を持つ列から、米国の州名、略称、数値コード、区分、地域のいずれかを返します。州の情報は、米国の州名、略語 (FIPS / ANSI コード)、数値コード (FIPS) のいずれかであり、任意の組み合わせが可能です。

シンタックス
statecode(<州の列>, output_type = <出力のタイプ>)

引数

出力のタイプ:

返り値
State name, State code, etc.

例
statecode(X1, "name") X1列の州コードを、州の正式名称に変換します。

X1 NEW
CA California
NY New York
TX Texas

statecode(X1, "num_code") X1列の州コードまたは州名を、州の数値コードに変換します。

X1 NEW
CA 06
California 06
NY 36

statecode(X1, "region") X1列の州コードを、所属する地域名に変換します。

X1 NEW
CA West
NY East
TX South

statecode(X1, "division") X1列の州コードを、所属する地域区分名に変換します。

X1 NEW
CA Pacific
NY Middle Atlantic
TX West South Central

countycode

概要
米国の州および郡名にをもとに米国の郡コード（FIPS - 連邦情報処理標準）を生成します。

シンタックス
countycode(state = <州名の列>, county = <郡名の列>)

引数

返り値
County code

例

countycode("California", "San Mateo")
06081を返します。

countycode("CA", "San Mateo")
06081を返します。

countycode("CA", "San Mateo County")
06081を返します。

do_tokenize

概要
テキストをトークン化（単語や文などに分割）して、1行につき1つのトークンを返します。

シンタックス
do_tokenize(<テキストの列>, token = <トークンの種類>, keep_cols = <TRUE|FALSE>, to_lower = <TRUE|FALSE>, drop = <TRUE|FALSE>, output = <新しい列名>, with_id = <TRUE|FALSE>, pattern = <パターン>)

引数

返り値
Data Frame

例
元のデータ:

index text
First It was a great party.
Second She has just left. She will be off tomorrow.

do_tokenize(text) text列の値をトークン化します。

index document_id sentence_id token
First 1 1 it
First 1 1 was
First 1 1 a
First 1 1 great
First 1 1 party
Second 2 1 she
Second 2 1 has
Second 2 1 just
Second 2 1 left
Second 2 2 she
Second 2 2 will
Second 2 2 be
Second 2 2 off
Second 2 2 tomorrow

pair_count

概要
グループ内で共起する単語のペア（単語の組み合わせ）を数えます。

シンタックス
pair_count(group = <グループ列>, value = <値の列>, distinct = <TRUE|FALSE>, diag = <TRUE|FALSE>, sort = <TRUE|FALSE>, group_by = <グループ化する列>)

引数

返り値
Data frame

例

元データ

タイトル 単語
記事1 データ
記事1 分析
記事1 可視化
記事2 データ
記事2 科学
記事3 分析
記事3 可視化

pair_count(group = タイトル, value = 単語, distinct = FALSE, diag = FALSE, sort = TRUE) 「単語」列から「token.x」と「token.y」という2つの列を持ち、それらのペアの出現回数を「value」列として含むデータフレームを返します。

token.x token.y value
データ 分析 1
データ 可視化 1
データ 科学 1
分析 可視化 2
分析 科学 0
可視化 科学 0

do_tfidf

概要
各グループに対する各単語のTF-IDF（Term Frequency-Inverse Document Frequency）を計算します。TF-IDFは、単語の出現頻度に基づいて重要度を上げる一方、文書頻度に基づいて重要度を下げることにより、各文書内の各単語の重要性を計算する重み付け手法です。

シンタックス
do_tfidf(<文書列>, <トークン列>, tf_weight = <TF重み付けタイプ>, idf_log_scale = <関数>, norm = "l2"|"l1"|FALSE)

引数

返り値
Data Frame

例
元のデータ:

document_id token
1 this
1 is
1 what
1 it
1 is
2 which
2 is
2 better

do_tfidf(document_id, token) 各文書内の各単語に対するTF-IDFスコアを計算します。

document_id token count_per_doc count_of_docs tfidf
1 is 2 2 0.0000000
1 it 1 1 0.5773503
1 this 1 1 0.5773503
1 what 1 1 0.5773503
2 better 1 1 0.7071068
2 is 1 2 0.0000000
2 which 1 1 0.7071068

do_ngram

概要
文章内のトークンを連結してn-gramの列を作成します。

シンタックス
do_ngram(<トークン列>, <文書列>, <文ID列>, maxn = <数値>, sep = <テキスト>)

引数

返り値
Data Frame

例
元のデータ:

document_id sentence_id token
1 1 it
1 1 is
1 1 good
2 1 she
2 1 left
2 2 she
2 2 will
2 2 come
2 2 tomorrow

do_ngram(token, document_id, sentence_id, maxn=3) トークンから最大3単語までのn-gramを作成します。

document_id sentence_id gram token
1 1 1 it
1 1 1 is
1 1 1 good
1 1 2 it_is
1 1 2 is_good
1 1 3 it_is_good
2 1 1 she
2 1 1 left
2 1 2 she_left
2 2 1 she
2 2 1 will
2 2 1 come
2 2 1 tomorrow
2 2 2 she_will
2 2 2 will_come
2 2 2 come_tomorrow
2 2 3 she_will_come
2 2 3 will_come_tomorrow

do_cosine_sim.kv

概要
コサイン類似度アルゴリズムを使用して、各ドキュメント間の類似度を計算します。コサイン類似度は多次元空間における2つのベクトル間の角度のコサインを測定します。テキストマイニングにおいては、文書間の類似性を数値化するのに役立ちます。

シンタックス
do_cosine_sim.kv(<列名>, <キー列>, <値列>, distinct = <論理値>, diag = <論理値>, fun.aggregate = <集約関数>)

引数

返り値 Data Frame

例

元のデータ:

文書ID 単語 値
文書1 これ 0.8966972
文書1 でした 0.2655087
文書1 良い 0.3721239
文書2 彼女 0.5728534
文書2 です 0.9082078
文書2 素敵 0.2016819
文書3 彼女 0.8983897
文書3 です 0.9446753
文書3 良い 0.6607978

do_cosine_sim.kv(文書ID, 単語, 値) 各文書間のコサイン類似度を計算します。値が1に近いほど類似度が高いことを示します。

文書ID.x 文書ID.y 値
文書1 文書2 0.0000000
文書1 文書3 0.1671574
文書2 文書1 0.0000000
文書2 文書3 0.8595770
文書3 文書1 0.1671574
文書3 文書2 0.8595770

do_cmdscale

概要
多次元尺度法（MDS）を実行します。エンティティのペア間の距離から近似的な座標を計算します。これにより高次元データを視覚化しやすい低次元空間（通常は2次元や3次元）に射影できます。

シンタックス
do_cmdscale(<列名1>, <列名2>, <値列>, k = <整数>)

引数

返り値
Data Frame

例

元のデータ:

名前1 名前2 距離
牛 馬 36
牛 亀 82
馬 亀 48

do_cmdscale(名前1, 名前2, 距離) エンティティ間の距離から2次元座標を計算します。

name V1 V2
牛 -38.915551 -3.435417
馬 -4.163866 5.962475
亀 43.079417 -2.527058

impute_na

概要

impute_naでは、平均値や中央値や最頻値、手動で指定した値、または線形回帰モデルによる予測値によって欠損値を埋めることができます。予測値を使って埋める場合は、予測変数の列を指定する必要があり、予測変数の列は複数指定が可能です。

シンタックス

impute_na(<欠損値を埋めたい列>, type = <欠損値を埋めるタイプ>, val = <値または列>, <予測変数の列>)

引数

例

mutate(New = impute_na(DEP_DELAY, type = "mean"))

DEP_DELAY列の欠損値を、その列の平均値で補完します。

CARRIER DEP_DELAY NEW
UA 7 7
UA NA 8.75
UA 0 0
AA 20 20
AA NA 8.75
AA 8 8

mutate(New = impute_na(DEP_DELAY, type = "median"))

DEP_DELAY列の欠損値を、その列の中央値で補完します。

CARRIER DEP_DELAY NEW
UA 7 7
UA NA 7.5
UA 0 0
AA 20 20
AA NA 7.5
AA 8 8

mutate(New = impute_na(製品カテゴリー, type = "mode"))

製品カテゴリー列の欠損値を、その列の最頻値（もっとも頻繁に出現する値）で補完します。

製品ID 製品カテゴリー NEW
001 食品 食品
002 NA 食品
003 衣料品 衣料品
004 食品 食品
005 NA 食品
006 日用品 日用品

mutate(New = impute_na(DEP_DELAY, type = "value", val = 10))

DEP_DELAY列の欠損値を10で補完します。

CARRIER ARR_DELAY DEP_DELAY DISTANCE NEW
UA 10 7 300 7
UA 20 NA 1000 10
UA -5 0 200 0
AA 20 20 500 20
AA -5 NA 700 10
AA 10 8 1000 8

mutate(New = impute_na(DEP_DELAY, type = "predict", CARRIER, ARR_DELAY, DISTANCE))

DEP_DELAY列の欠損値は、CARRIER、ARR_DELAY、および DISTANCE列からの予測値で線形回帰を用いて補完されています。

CARRIER ARR_DELAY DEP_DELAY DISTANCE NEW
UA 10 7 300 7
UA 20 NA 1000 3.47
UA -5 0 200 0
AA 20 20 500 20
AA -5 NA 700 3.59
AA 10 8 1000 8

detect_outlier

概要

外れ値を検出し、'upper'（上位）ラベルと'lower'（下位）ラベルを返します。

シンタックス

detect_outlier(<数値列>, type = <外れ値の検出方法>, threshold = <数値>)

引数

例

detect_outlier(DISTANCE, type = "iqr")) データの外れ値を検出して"Upper"、"Normal"、"Lower"のラベルを付けます。

CARRIER DISTANCE NEW
UA 800 Normal
UA 5000 Upper
UA 600 Normal
AA 500 Normal
AA 700 Normal
AA 10 Lower

build_model

概要
入力データフレームからモデル関数と引数によってモデルを含むデータフレームを作成します。

シンタックス
build_model(model_func = <モデル関数>, seed = <整数>, test_rate = <数値>, <モデルパラメータ>)

引数

返り値 Data Frame

例

元のデータ:

CARRIER ARR_DELAY DEP_DELAY DISTANCE WEIGHTS
UA 10 7 300 0.8
UA 20 30 1000 0.5
UA -5 0 200 1.2
AA 20 20 500 0.8
AA -5 3 700 0.9
AA 10 8 1000 0.5

build_model(model_func = lme4::lmer, formula = ARR_DELAY ~ DEP_DELAY + (DISTANCE|CARRIER), test_rate = 0.1, weights = WEIGHTS) 線形混合効果モデルを格納したデータフレームを返します。元のデータを含む列も返されます。

source_data model .test_index
source dataframe lme4 model c(1)

model_coefまたはmodel_stats関数を使用して、モデルのサマリ情報を取得できます。また、同じデータフレームに格納されているデータで予測するにはprediction関数を使用できます。

one_hot

概要
カテゴリカルデータの列をワンホットエンコーディングし、それぞれのカテゴリに対応する新しい列を作成します。新しい列は、行がそのカテゴリに該当する場合は1、それ以外は0を持ちます。

シンタックス
one_hot(<カテゴリ列>)

引数

返り値
Data Frame（元のデータフレームにワンホットエンコーディングされた列が追加されたデータ）

例

元データ：

ARR_DELAY CARRIER
10 UA
20 UA
-5 UA
20 AA
-5 AA
10 AA

one_hot(CARRIER)

ARR_DELAY CARRIER_UA CARRIER_AA
10 1 0
20 1 0
-5 1 0
20 0 1
-5 0 1
10 0 1

get_mode

概要

最も頻度の多い値を返します。

シンタックス

get_mode(<列名>, na.rm = <TRUE|FALSE>)

引数

例 get_mode(到着遅れ) 到着遅れの最頻値を返します。

到着遅れ 航空会社 NEW
10 UA 20
20 UA 20
-5 UA 20
20 AA 20

get_mode(航空会社) 航空会社の最頻値を返します。

到着遅れ 航空会社 NEW
10 UA UA
20 UA UA
-5 UA UA
20 AA UA

summarize_group

概要

指定した集計関数を利用して列の値を集計します。 グループ化をしている場合、各グループの値を集計します。

シンタックス

summarize_group(group_cols=<列のリスト>, group_funs = <関数>, ...)

引数

例

元のデータ:

到着遅れ 航空会社
10 UA
20 UA
30 UA
-20 UA
20 AA
-5 AA
-9 AA

summarize_group(group_cols=c("航空会社"), group_funs=("none"), 到着遅れ_平均 = mean(到着遅れ))

航空会社 到着遅れ_平均
UA 10
AA 2

元のデータ:

到着遅れ 出発遅れ 航空会社
10 20 UA
20 15 UA
30 -5 UA
-20 30 UA
20 10 AA
-5 20 AA
-9 30 AA

summarize_group(group_cols=c("航空会社"), group_funs=("none"), 到着遅れ平均 = mean(到着遅れ), DEP_DEALY合計 = sum(出発遅れ))

航空会社 到着遅れ_平均 出発遅れ_合計
UA 10 60
AA 2 60

元のデータ:

日付 到着遅れ 出発遅れ
06/01/2018 10 20
06/12/2018 20 15
06/18/2018 30 -5
06/21/2018 -20 30
07/14/2018 20 10
07/16/2018 -5 20
07/25/2018 -9 30

summarize_group(group_cols=c("FL_DATE"), group_funs=("month"), 到着遅れ平均 = mean(到着遅れ), 出発遅れ合計 = sum(出発遅れ))

日付_月 到着遅れ_平均 出発遅れ_合計
6 10 60
7 2 60

summarize_row

概要

指定した集計関数を利用して、各行の列の値を集計 します。

シンタックス

引数

例

mutate(NEW = summarize_row(across(c(X1, X2, X3)), sum)) 行ごとに指定した列の値を合計し、「合計」列を作成します。いずれかの列の値がNAの場合、結果もNAになります。

X1 X2 X3 NEW
2 1 10 13
11 4
5 7 4 16

mutate(NEW = summarize_row(across(c(X1, X2, X3)), sum, na.rm = TRUE)) 上記の例と同じ結果を返します。ただし、列の値のいくつかがNAであっても、結果は残りの値から計算されます。

X1 X2 X3 NEW
2 1 10 13
11 4 15
5 7 4 16

mutate(NEW = summarize_row(across(where(is.numeric)), sum, na.rm = TRUE)) 行ごとにすべての数値列の値を合計します。

X1 X2 X3 NEW
2 1 10 13
11 4 15
5 7 4 16

mutate_group

概要

表計算などの指定された関数を使用して、新しい列を作成するか、既存の列を上書きます。グループ化をしているときには、グループごとに計算が実行されます。

シンタックス

mutate_group(group_cols=<列のリスト>, group_funs = <関数>, sort_cols=<列のリスト>, sort_funs = <関数>, ...)

引数

例 mutate_group(group_cols=c("X1"), group_funs=("none"), NEW = cumsum(X2)) X1の値でグループ化して、X2列の累積合計値を返します。 | X1 | X2 | NEW | | ---- | ---- | ---- | | UA | 10 | 10 | | UA | 20 | 30 | | UA | 30 | 60 | | UA | 20 | 80 | | AA | 20 | 20 | | AA | 5 | 25 | | AA | 9 | 34 |

mutate_group(group_cols=c("X1"), group_funs=("none"), NEW1 = X2 - lag(X2), NEW2 = X3 - lag(X3)) X1の値でグループ化して、X2列の前の行との値の差をNEW1列として返して、X3列の前の行との値の差をNEW2列として返します。

X1 X2 X3 NEW1 NEW2
AA 20 10
AA -5 20 -25 10
AA -9 30 -4 10
UA 10 20
UA 20 15 10 -5
UA 30 -5 10 -20
UA -20 30 -50 35

sum_if

概要

指定した条件を満たす合計値を返します。

シンタックス

sum_if(<列名>, <条件>,... , na.rm = <TRUE|FALSE>)

引数

返り値

Numeric

例

summarize(total = sum_if(売上合計, 商品 == 'パソコン' & 国 %in% c("Japan", "United States", "United Kingdom"))) 商品が「PC」で、国名が「Japan」、「United States」、「United Kingdom」のいずれかの売上の合計を計算する新しい列を作成ます。

summarize(total = sum_if(数量, 優先度 == 'P1' | 国 == "United States")) 優先度が「P1」または国が 「United States」 の数量の合計を計算する新しい列を作成します。

sum_if_ratio

概要

指定した条件を満たす合計値の、すべての値の合計値に対する比率を返します。

シンタックス

sum_if_ratio(<列名>, <条件>,... , na.rm = <TRUE|FALSE>)

引数

返り値

Numeric

例

summarize(total = sum_if_ratio(売上, 商品== 'パソコン' & 国 %in% c("Japan", "United States", "United Kingdom"))) 商品が「PC」で、国が「Japan」「United States」「United Kingdom」のいずれかの売上合計の、各グループの売上合計に対する比率を計算する新しい列を作成する。

count_if

概要

指定した条件を満たす行の数を集計します。

シンタックス

count_if(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

例

summarize(国の数 = count_if(国, 商品 == ‘’パソコン | 数量 > 10)) グループごとに商品が'パソコン'、または数量が10より大きい行の数を返します。

count_if_ratio

概要

総行数に対する指定した条件を満たす行の数の比率を集計します。

シンタックス

count_if_ratio(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

例

summarize(国の割合 = count_if_ratio(国, 商品 == 'パソコン' | 数量 > 10)) グループごとの行の数に対する、商品が'パソコン'または数量が10より大きい行の数の比率を返します。

count_unique_if

概要

指定した条件を満たす行に由来する列の一意な値の数を数えます。

シンタックス

count_unique_if(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

例

summarize(country_count = count_unique_if(国, 商品 == 'パソコン' & 数量 > 10)) グループごとに商品が'パソコン'で、数量が10より大きい行に対する一意な国の数を返します。

count_unique_if_ratio

概要

指定した条件を満たす行から得られる一意の値の数と、一意の値の数の比率を返します。

シンタックス

count_unique_if_ratio(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

例

summarize(国の数の比率 = count_unique_if_ratio(国, 商品 == 'パソコン' & 数量 > 10)) 商品が'パソコン'で数量が10より大きい行のユニークな国の数と、各グループのユニークな国の数の比率を返します。

mean_if

概要

指定した条件を満たす平均値を返します。

シンタックス

mean_if(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

返り値

Numeric

例

summarize(売上の平均値 = mean_if(売上), 商品 == 'パソコン' | 数量 > 10))
グループごとに、商品が「PC」、または数量が10より大きい売上の平均値を計算する新しい列を作成します。

average_if

概要

指定した条件を満たす平均値を返します。 average_if関数は mean_if のエイリアスです。

シンタックス

average_if(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

返り値

Numeric

例

summarize(売上の平均値 = average_if(売上), 商品 == 'パソコン' | 数量 > 10))
グループごとに、商品が「PC」、または数量が10より大きい売上の平均値を計算する新しい列を作成します。

median_if

概要

指定した条件を満たす中央値を返します。

シンタックス

median_if(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

返り値

Numeric

例

summarize(売上の中央値 = median_if(売上), 商品 == 'パソコン' | 数量 > 10))
グループごとに、商品が「PC」、または数量が10より大きいの売上の中央値を計算する新しい列を作成します。_

max_if

概要

指定した条件を満たす数値列の最大値を返します。

シンタックス

max_if(<列名>, <条件>, ... , na.rm = <TRUE|FALSE>)

引数

返り値
数値、日付、または日時（入力の列の型と同じ）

例

max_if(購入金額, 顧客区分 == "プレミアム")

「顧客区分」が「プレミアム」である顧客の最大「購入金額」を返します。

注文ID 顧客区分 購入金額 結果
O001 一般 15000 58000
O002 プレミアム 58000 58000
O003 プレミアム 42000 58000
O004 一般 25000 58000

max_if(購入日, 商品名 == "スマートフォンX")

「商品名」が「スマートフォンX」の商品を最後に購入した日付を返します。

注文ID 商品名 購入日 結果
O001 タブレットY 2023-06-15 2023-05-22
O002 スマートフォンX 2023-02-10 2023-05-22
O003 ノートPCZ 2023-04-05 2023-05-22
O004 スマートフォンX 2023-05-22 2023-05-22

min_if

概要

指定した条件を満たす行の中から、数値列の場合は最小値、日付の列の場合は最初の日を返します。例えば、特定の製品カテゴリでの最小の販売価格や、特定の製品を購買した最初の日を取得する際に使用できます。

シンタックス

min_if(<列名>, <条件>, ..., na.rm = <TRUE|FALSE>)

引数

返り値
数値、日付、または日時（入力の列の型と同じ）

例

min_if(販売価格, 商品カテゴリ == "電化製品")

「商品カテゴリ」が「電化製品」である商品の最小「販売価格」を返します。

商品ID 商品カテゴリ 販売価格 結果
E001 電化製品 25000 12000
F001 食品 5000 12000
E002 電化製品 12000 12000
C001 衣料品 8000 12000

min_if(購入日, 商品名 == "ノートパソコンA")

「商品名」が「ノートパソコンA」の商品を最初に購入した日付を返します。

注文ID 商品名 購入日 結果
O001 タブレットB 2023-03-15 2023-01-20
O002 ノートパソコンA 2023-01-20 2023-01-20
O003 スマートフォンC 2023-02-10 2023-01-20
O004 ノートパソコンA 2023-04-05 2023-01-20

count_rows

概要
グループごとの行の数を集計します。

シンタックス
count_rows()

引数

返り値
Numeric

例
summarize(total = count_rows())
グループごとの行の数を計算する新しい列を作成します。

count_unique

概要
一意な値の数を返します。

シンタックス
count_unique(<列名>, na.rm = <TRUE|FALSE>)

引数

返り値
Numeric

例
summarize(total = count_unique(飛行機の機体番号))
グループごとに、飛行機の機体番号の一意な数を計算する新しい列を作成します。

summarize(total = count_unique(州, 都市))
グループごとに州と都市のユニークな組み合わせの数を計算する新しい列を作成します。

weekend

概要
指定した日付列の値をもとに、平日か週末かのラベルをつけます。

シンタックス
weekend(<日付列>)

引数

返り値
Factor (either Weekday or Weekend)

例
weekend(X1) X1列の日付が週末かどうかを判定します。

X1 NEW
2015-10-01 Weekday
2015-10-02 Weekend
2015-10-03 Weekend

is_japanese_holiday

概要 is_jholiday関数のエイリアスです。指定した日付が日本の祝日の場合、TRUEを返します。

シンタックス
is_japanese_holiday(<日付列>)

引数

返り値
Factor (either TRUE or FALSE)

例
is_japanese_holiday(X1) X1列の日付が日本の祝日かどうかを判定します。

X1 NEW
2020-01-01 TRUE
2020-01-02 FALSE
2020-01-05 FALSE

get_week_of_month

概要
月の週を抽出します。例えば、指定した日付が月の第1週であれば 1 を返します。

シンタックス
get_week_of_month(<日付列>)

返り値
Numeric

例
get_week_of_month(X1) X1列の日付が該当月の何週目かを返します。

X1 NEW
2019-06-01 1
2019-06-15 3
2019-06-25 5

sample_rows

概要
データフレームからn行をサンプリングします。sample_n関数と似ていますが、指定された行数がデータの行数より多い場合にエラーを発生させずに処理できる点が異なります。

シンタックス
sample_rows(<数値>, weight = <数値列>, replace = <論理値>, seed = <数値>)

引数

返り値
Data Frame

例

元のデータ:

顧客ID 購入金額 商品カテゴリ
C001 5000 家電
C002 3000 食品
C003 12000 家具
C004 8000 衣料品
C005 15000 家電
C006 7000 食品

sample_rows(3) データフレームから3行をランダムに選択します。

顧客ID 購入金額 商品カテゴリ
C003 12000 家具
C006 7000 食品
C001 5000 家電

sample_rows(3, weight = 購入金額) 購入金額の列に重みを付けて、データフレームから3行をランダムに選択します。購入金額が大きい行が選択される確率が高くなります。

顧客ID 購入金額 商品カテゴリ
C005 15000 家電
C003 12000 家具
C004 8000 衣料品

confint_mean

概要
与えられた数値データから、平均の信頼区間（信頼区間の半分の幅）を返します。

シンタックス
confint_mean(<数値列>, level=<数値>)

引数

返り値
Numeric

例
confint_mean(給料) 給料の平均の信頼区間（信頼区間の半分の幅）を返します。

給料 NEW
2200 1139.334662
3000 1139.334662
5000 1139.334662
4000 1139.334662
3200 1139.334662
2200 1139.334662

confint_ratio

概要
指定したロジカル型のデータからTRUEの割合の信頼区間（信頼区間の半分の幅）を返します。

シンタックス
confint_ratio(<ロジカル型の列>, level=<数値>)

引数

返り値
Numeric

例
confint_ratio(X1) X1列のTRUEの割合に対する信頼区間（信頼区間の半分の幅）を計算します。主に集計の際に使用されますが、計算を作成でも使用することができます。

X1 NEW
TRUE 0.02065466
FALSE 0.02065466
TRUE 0.02065466

calc_confint_mean

概要
サンプルデータのサイズと標準偏差から、平均の信頼区間（信頼区間の半分の幅）を返します。

シンタックス
calc_confint_mean(<数値列>, <数値列>. level=<数値>)

引数

返り値
Numeric

例
calc_confint_mean(標準偏差, 従業員数)

部署 標準偏差 従業員数 NEW
営業 577.4946 2000 25.32468
研究開発 288.8194 1000 17.9226

calc_confint_ratio

概要
サンプルデータのサイズと標準偏差から、TRUEの割合の信頼区間（信頼区間の半分の幅）を返します。

シンタックス
calc_confint_ratio(<数値列>, <数値列>. level=<数値>)

引数

返り値
Numeric

例
calc_confint_ratio(X1, X2) 退職率（割合）と従業員数（サンプル数）から割合の信頼区間を計算して返します。

部署 離職率 従業員数 NEW
営業 0.33 2000 0.02065466
人事 0.25 1000 0.02683791
研究開発 0.20 500 0.03508232

cumsum_decayed

概要
減衰効果の累積和を計算します。第二引数のRが1の場合は、cumsum関数と同じ結果を得られます。

シンタックス
cumsum_decayed(<数値列>, <数値>)

引数

返り値 Numeric

例 cumsum_decayed(広告の効果, 0.1)) | 広告の効果 | NEW | | ---------: | ---------------: | | 100 | 100 | | 200 | 210 | | 100 | 121 | | 100 | 112.1 |

years_between

概要
2つの日付間の期間を年数で計算します。

シンタックス
years_between(<日付型の列>, <日付型の列>)

引数

返り値
numeric

例 years_between(X1, X2) X1列とX2列の間の経過年数を計算します。

X1 X2 NEW
2020-10-01 2021-10-01 1
2019-05-15 2022-05-15 3
2018-12-31 2023-12-31 5

months_between

概要
2つの日付間の期間を月数で計算します。

シンタックス
months_between(<日付型の列>, <日付型の列>)

引数

返り値
numeric

例 months_between(X1, X2) X1列とX2列の間の経過月数を計算します。

X1 X2 NEW
2020-10-01 2021-10-01 12
2019-05-15 2022-05-15 36
2018-12-31 2023-12-31 60

weeks_between

概要
2つの日付間の期間を週数で計算します。

シンタックス
weeks_between(<日付型の列>, <日付型の列>)

引数

返り値
numeric

例 weeks_between(X1, X2) X1列とX2列の間の経過週数を計算します。

X1 X2 NEW
2020-10-01 2021-10-01 52.14285714
2019-05-15 2022-05-15 156.5714286
2018-12-31 2023-12-31 260.8571429

days_between

概要
2つの日付間の期間を日数で計算します。

シンタックス
days_between(<日付型の列>, <日付型の列>)

引数

返り値
numeric

例
days_between(X1, X2) X1列とX2列の間の経過日数を計算します。

X1 X2 NEW
2020-10-01 2021-10-01 365
2019-05-15 2022-05-15 1095
2018-12-31 2023-12-31 1825

hours_between

概要
2つの日付間の期間を時間で計算します。

シンタックス
hours_between(<日付・時間型の列>, <日付・時間型の列>)

引数

返り値
numeric

例 hours_between(X1, X2) X1列とX2列の間の経過時間を計算します。

X1 X2 NEW
2020-10-01 05:00:00 2020-10-01 15:00:00 10
2020-10-01 08:30:00 2020-10-02 08:30:00 24
2020-10-01 12:00:00 2020-10-03 00:00:00 36

minutes_between

概要
2つの日付間の期間を分で計算します。

シンタックス
minutes_between(<日付・時間型の列>, <日付・時間型の列>)

引数

返り値
numeric

例
minutes_between(X1, X2) X1列とX2列の間の経過分数を計算します。

X1 X2 NEW
2020-10-01 05:00:00 2020-10-01 15:00:00 600
2020-10-01 08:30:00 2020-10-02 08:30:00 1440
2020-10-01 12:00:00 2020-10-03 00:00:00 2160

seconds_between

概要
2つの日付間の期間を秒で計算します。

シンタックス
seconds_between(<日付・時間型の列>, <日付・時間型の列>)

引数

返り値
numeric

例
seconds_between(X1, X2) X1列とX2列の間の経過秒数を計算します。

X1 X2 NEW
2020-10-01 05:00:00 2020-10-01 15:00:00 36000
2020-10-01 08:30:00 2020-10-02 08:30:00 86400
2020-10-01 12:00:00 2020-10-03 00:00:00 129600

last_date

概要 指定した単位（月など）における、最後の日付を返します。

シンタックス last_date(<日付列>, unit = "week"|"month"|"quarter"|"year", previous = <TRUE|FALSE>, week_start = <数値>)

引数

返り値 Date

例 last_date(X1, unit = "month") X1列の日付の月の最終日を返します。

X1 NEW
2022-10-01 2022-10-31
2022-11-15 2022-11-30
2022-02-01 2022-02-28

ts_lag

概要
特定の値の指定した前期間の値を返します。

シンタックス
ts_lag(<日付列>, <数値列>, unit = "day"|"week"|"month"|"quarter"|"year", n = <整数値>, na_fill_type = "previous"|"next"|"none")

引数

返り値 numeric

例 ts_lag(Date, Sales, unit="year", na_fill_type="previous", n=1) 1年前のSalesの値を返します。

Date Sales NEW
2020-01-01 2259450.896 NA
2021-01-01 2677438.694 2259450.896
2022-01-01 3405746.449 2677438.694
2023-01-01 4299865.871 3405746.449

ts_diff

概要 特定の値の指定した前期間との差を計算します。

シンタックス
ts_diff(<日付列>, <数値列>, unit = "day"|"week"|"month"|"quarter"|"year", n = <整数値>, na_fill_type = "previous"|"next"|"none")

引数

返り値 numeric

例 ts_diff(Date, Sales, unit="year", na_fill_type="previous", n=1) 1年前のSalesの値との差を返します。

Date Sales NEW
2020-01-01 2259450.896 NA
2021-01-01 2677438.694 417987.7989
2022-01-01 3405746.449 728307.755
2023-01-01 4299865.871 894119.4212

ts_diff_ratio

概要 特定の値の指定した前期間との差の割合を計算します。

シンタックス
ts_diff_ratio(<日付列>, <数値列>, unit = "day"|"week"|"month"|"quarter"|"year", n = <整数値>, na_fill_type = "previous"|"next"|"none")

引数

返り値 numeric

例 ts_diff_ratio(Date, Sales, unit="year", na_fill_type="previous", n=1)*100 1年前のSalesの値との差の割合を返します。

Date Sales NEW
2020-01-01 2259450.896 NA
2021-01-01 2677438.694 18.49953012
2022-01-01 3405746.449 27.20165943
2023-01-01 4299865.871 26.25325856

likert_sigma

概要
1="強くそう思わない"、2="そう思わない"、3="どちらでもない"、4="そう思う"、5="強くそう思う "のようなアンケートの回答データの列からリッカートのシグマ値を返します。

シンタックス
likert_sigma(<数値列>)

引数

返り値
Numeric

例
likert_sigma(アイスクリームがどれだけ好きか)

名前 アイスクリームがどれだけ好きか NEW
Joe 5 0.7978846
Sally 4 -0.3246628
Bob 2 -1.2711063
John 5 0.7978846

exp_balance

概要
SMOTE（Synthetic Minority Oversampling Technique）を使用して、不均衡なデータをバランスの取れたデータに変換します。少数派の合成データを作成し、多数派クラスのデータを適切に調整することで、バイアスのない機械学習モデルを構築しやすくします。

対象となる列は0/1 の数値、または 2 値のカテゴリデータ、ロジカル型の列に限定されます。

シンタックス

exp_balance(<不均衡を調整したい列>, target_minority_perc = <目標とする少数派データの割合>, target_size = <目標とするデータの行数>, max_synth_perc = <少数派データの増加率の上限>, k = <近傍数>, seed = <シード値>)

引数

返り値
Data Frame

例

元データのクラス分布（航空便の遅延データ）：

Flight_ID Delayed
1001 TRUE
1002 FALSE
1003 FALSE
1004 FALSE
1005 FALSE
1006 FALSE
1007 FALSE
1008 TRUE

DelayedがTRUEの割合が少ないため、そのまま機械学習モデルを作成すると、予測が FALSEに偏る可能性があります。

exp_balance(Delayed, target_minority_perc = 50, target_size = 10, max_synth_perc = 200, k = 5, seed = 0)

少数派データ（TRUE）の割合を50%に調整し、目標とするデータの行数を10に設定。

Flight_ID Delayed Synthesized
1001 TRUE TRUE
1002 FALSE FALSE
1003 FALSE FALSE
1004 FALSE FALSE
1005 FALSE FALSE
1006 FALSE FALSE
2001 TRUE TRUE
2002 TRUE TRUE
2003 TRUE TRUE
2004 TRUE TRUE

合成データ（Synthesized = TRUE）が追加され、DelayedがTRUEのデータが増え、不均衡が調整されます。

prefecturecode

概要
都道府県名を対応する都道府県コード（JIS X 0401で定義された2桁の数値コード）に変換します。例えば「東京都」は「13」、「大阪府」は「27」に変換されます。

シンタックス
prefecturecode(<都道府県名の列>, output_type = "code")

引数

返り値
Character

例
prefecturecode(都道府県名, output_type = "code") 都道府県名を対応する都道府県コードに変換します。

都道府県名 都道府県コード
東京都 13
大阪 27
北海道 01
沖縄県 47

exp_cut_by_step

概要
数値データを等間隔（例：500刻み）でグループに分けて、該当するグループ名を返します。format_cut_output関数と組み合わせることで、区間の表示形式をカスタマイズできます。

シンタックス
exp_cut_by_step(<数値列>, step = <区間の幅>, lower.range = <最小値>, upper.range = <最大値>, right = <TRUE|FALSE>, include.outside.range = <TRUE|FALSE>, dig.lab = <表示桁数>, as.factor = <TRUE|FALSE>)

引数

返り値
Factor

例
format_cut_output(exp_cut_by_step(売上金額, step = 10000), right = FALSE, decimal.digits = 0) 売上金額を10000刻みで等間隔のグループに分けます。各グループの下限値を含める形で分類し、該当するグループ名を整数表記で返します。

売上金額 区間
5000 < 5,000
15000 5,000 - 15,000
25000 15,000 - 25,000

format_cut_output(exp_cut_by_step(売上金額, step = 5000, lower.range = 0, upper.range = 20000, right = TRUE), right = TRUE, decimal.digits = 0) 売上金額を0から20000の範囲に制限し、5000刻みで等間隔のグループに分けます。各グループの上限値を含める形で分類し、該当するグループ名を整数表記で返します。

売上金額 区間
5000 0 - 5,000
15000 10,000 - 15,000
25000 20,000 <

exp_cut

概要
数値データを等幅でグループに分けて、該当するグループ名を返します。format_cut_output関数と組み合わせることで、区間の表示形式をカスタマイズできます。

シンタックス
exp_cut(<数値列>, breaks = <区間数>, lower.range = <最小値>, upper.range = <最大値>, right = <TRUE|FALSE>, include.outside.range = <TRUE|FALSE>, dig.lab = <表示桁数>, as.factor = <TRUE|FALSE>)

引数

返り値
Factor

例
format_cut_output(exp_cut(売上金額, breaks = 5), right = TRUE, decimal.digits = 2) 売上金額の値を最小値と最大値をもとに等幅で3つのグループに分割し、どのグル-プに属するかの値を返します。グループ名には小数点第2位までの情報を表示します。

売上金額 グループ
1 1 - 5,000
4800 1 - 5,000
13000 10,000 - 15,000
25000 20,000 - 25,000

format_cut_output(exp_cut(売上金額, breaks = 4, lower.range = 0, upper.range = 20000, right = TRUE), right = TRUE, decimal.digits = 2) 売上金額をの範囲を0から20000の間で等幅で4つのグループに分割し、どのグループに属するかの値を返します。各グループの上限値を含める形で分類し、グループ名には小数点第2位までの情報を表示します。

売上金額 グループ
1 0.00 - 5,000.00
4800 0.00 - 5,000.00
13000 10,000 - 15,000
25000 20,000.00 <

logistic

概要
数値列に対してロジスティック関数を適用した結果を返すことができます。

シンタックス
logistic(<数値列>)

返り値
Numeric

例
logistic(X1) X列に対してロジスティック関数を適用した結果を返します。

X1 NEW
1 0.7310585786
2 0.880797078
3 0.9525741268
4 0.98201379
5 0.9933071491
6 0.9975273768
7 0.9990889488
8 0.9996646499
9 0.9998766054
10 0.9999546021

is_jholiday

概要 指定された日付が日本の祝日だった場合にTRUEを返します。

シンタックス
is_jholiday(<日付列>)

引数

返り値
Logical（TRUEまたはFALSEのどちらかを返します）

例
is_jholiday(日付) X1列の日付が日本の祝日かどうかを論理値で返します。

日付 祝日かどうか
2020-01-01 TRUE
2020-01-05 FALSE
2020-01-13 TRUE

str_conv_zenhan

概要
文字列内の全角文字と半角文字を変換します。また、文字列内の半角文字を全角文字に変換します。

シンタックス
str_conv_zenhan(<テキストの列>, to = "zenkaku"|"hankaku")

引数

返り値
Character

例 str_conv_zenhan(X1, "zenkaku") 半角の文字列を全角文字に変換します。

X1 NEW
ｶﾞｯ ガッ
ﾊﾛｰ ハロー
ABC ＡＢＣ

str_conv_zenhan(X1, to = "hankaku") 全角の文字列を半角文字に変換します。

X1 NEW
ガッ ｶﾞｯ
ハロー ﾊﾛｰ
ＡＢＣ ABC

str_conv_hirakana

概要
文字列内のひらがなとカタカナを相互に変換します。

シンタックス
str_conv_hirakana(<テキストの列>, to = "hiragana"|"katakana")

引数

返り値
Character

例
str_conv_hirakana(X1, to = "hiragana") カタカナの列をひらがなに変換します。

X1 NEW
アイウエオ あいうえお
カタカナ かたかな
ヤマダ やまだ

str_conv_hirakana(X1, to = "katakana") ひらがなの列をカタカナに変換します。

X1 NEW
あいうえお アイウエオ
かたかな カタカナ
やまだ ヤマダ

separate_japanese_address

概要 日本の住所文字列を都道府県、市区町村、町名番地に分割します。

シンタックス separate_japanese_address(<住所の列>, prefecture_col = <都道府県の列名>, city_col = <市区町村の列名>, street_col = <町名番地の列名>)

引数

返り値 Character

例

separate_japanese_address(住所) 住所列の文字列をprefecture、city、streetに分割します。

住所 prefecture city street
東京都千代田区丸の内1-1-1 東京都 千代田区 丸の内1-1-1
大阪府大阪市中央区北浜1-1-1 大阪府 大阪市中央区 北浜1-1-1
北海道札幌市中央区北1条西2丁目 北海道 札幌市中央区 北1条西2丁目

separate_japanese_address(住所, prefecture_col = "都道府県", city_col = "市区町村", street_col = "町名番地")

住所列の文字列を分割した際の列名を都道府県、市区町村、町名番地にして分割します。

住所 都道府県 市区町村 町名番地
東京都千代田区丸の内1-1-1 東京都 千代田区 丸の内1-1-1
大阪府大阪市中央区北浜1-1-1 大阪府 大阪市中央区 北浜1-1-1
北海道札幌市中央区北1条西2丁目 北海道 札幌市中央区 北1条西2丁目

convert_jdate

概要
日本の和暦形式の文字列（例: 令和3年1月1日、R3/1/1）を西暦形式の日付（例: 2021-01-01）に変換します。

シンタックス
convert_jdate(<和暦形式の文字列>, legacy = <TRUE|FALSE>)

引数

返り値
Date

例

convert_jdate(和暦の文字列) 和暦の文字列を西暦形式の日付に変換します。

和暦の文字列 西暦の日付列
令和3年1月1日 2021-01-01
R3/1/1 2021-01-01
平成31年4月30日 2019-04-30

convert_jyear

概要
和暦年（令和、平成、昭和など）を西暦年に変換します。元号の漢字表記（令和三年）とアルファベット表記（R3）の両方に対応しています。

シンタックス
convert_jyear(<和暦年>, legacy = <TRUE|FALSE>)

引数

返り値
Numeric

例
convert_jyear(和暦年) 和暦年を西暦年に変換します。

和暦年 西暦年
令和3年 2021
R3 2021
平成元年 1989
昭和64年 1989

convert_prefecture

概要
都道府県名を漢字形式（例: 東京都）またはローマ字形式（例: Tokyo-to）に相互変換します。住所データの正規化や標準化に利用できます。

シンタックス
convert_prefecture(<都道府県名の列>, to = "kanji"|"roman")

引数

返り値
Character

例
convert_prefecture(prefecture, to = "kanji")

ローマ字形式の都道府県名を漢字形式に変換します。

prefecture 都道府県
tokyo-to 東京都
osaka-fu 大阪府
hokkaido 北海道

convert_prefecture_from_kana

概要
ひらがなまたはカタカナで表記された都道府県名を漢字表記に変換します。住所データの正規化や名寄せ処理に利用できます。

シンタックス
convert_prefecture_from_kana(<カナの都道府県名>)

引数

返り値
Character

例

convert_prefecture_from_kana(都道府県_ひらがな)

ひらがな表記の都道府県名を漢字表記に変換します。

都道府県_ひらがな 都道府県_漢字
とうきょうと 東京都
おおさかふ 大阪府
ホッカイドウ 北海道

find_date_by_wday

概要
指定した年月の特定の曜日の日付を取得します。例えば、「2023年5月の第3火曜日」のような指定が可能です。祝日設定や定期的なスケジュール管理に便利です。

シンタックス
find_date_by_wday(<年>, <月>, <曜日>, <第何週>)

引数

返り値
Date

例

find_date_by_wday(2023, 5, 2, 3)

2023年5月の第3火曜日の日付を取得します。

入力値 出力値
(2023, 5, 2, 3) 2023-05-16
(2023, 1, 1, 1) 2023-01-01
(2023, 12, 7, 4) 2023-12-24

harmonize_prefecture_name

概要
都道府県名の表記を統一された形式に変換します。「都」「府」「県」の有無や、略称・正式名称の違いを吸収して、一貫性のある表記に揃えることができます。

シンタックス
harmonize_prefecture_name(<都道府県名>, to = "long"|"short")

引数

返り値
Character

例
harmonize_prefecture_name(都道府県_略称形式, to = "long")

都道府県名の略称形式（short）を正式名称形式（long）に統一します。

入都道府県_略称形式 都道府県_正式名称形式
東京 東京都
大阪府 大阪府
京都 京都府

is_prefecture

概要
文字列が正しい都道府県名かどうかを判定します。市区町村名などの余分な文字列が含まれている場合や、正しくない都道府県名の場合はFALSEを返します。

シンタックス
is_prefecture(<文字列>)

引数

返り値
Logical

例

is_prefecture(都道府県名)

文字列が正しい都道府県名かどうかを判定します。

都道府県名 都道府県判定
東京都 TRUE
大阪 TRUE
東京都新宿区 FALSE
とうきょう FALSE

is_zipcode

概要
文字列が日本の郵便番号として正しい形式かどうかを判定します。7桁の数字のみの形式とハイフン区切りの形式の両方に対応しています。

シンタックス
is_zipcode(<文字列または数値>)

引数

返り値
Logical

例

is_zipcode(郵便番号)

文字列が正しい郵便番号の形式かどうかを判定します。

郵便番号 郵便番号判定
100-0001 TRUE
1000001 TRUE
100-001 FALSE
abc-defg FALSE

str_jconv

概要
日本語の文字種（ひらがな、カタカナ、全角、半角など）を相互に変換します。変換関数と変換先の形式を指定することで、様々な文字種の変換に対応できます。

シンタックス
str_jconv(<文字列>, fun = <変換関数>, to = <変換先形式>)

引数

返り値
Character

例

str_jconv("カタカナの列", str_conv_hirakana, to = "hiragana")

カタカナをひらがなに変換します。

カタカナの列 ひらがなの列
カタカナ かたかな
アイウエオ あいうえお

str_jnormalize

概要
文字列を正規化された形式に変換します。全角英数字の半角化、空白文字の統一、重複する空白の削除などを行います。

シンタックス
str_jnormalize(<文字列>)

引数

返り値
Character

例

str_jnormalize(文字列)

文字列を正規化された形式に変換します。

文字列 正規化後の文字列
ＡＢＣ　１２３ ABC 123
デ　ー　タ データ
Ｒ＆Ｄ部門 R&D部門

zipcode_spacer

概要
郵便番号の形式を整形します。数字のみの形式とハイフン付きの形式を相互に変換できます。データの標準化や表示形式の統一に利用できます。

シンタックス
zipcode_spacer(<郵便番号>, remove = <TRUE|FALSE>)

引数

返り値
Character

例

zipcode_spacer(郵便番号, remove = FALSE>)

郵便番号の形式を整形します。

郵便番号 郵便番号_変換後
1000001 100-0001
100-0001 100-0001

kansuji2arabic_num

概要
漢数字（一、二、三など）をアラビア数字の文字列（1、2、3など）に変換します。この関数は数値ではなく文字列を返すため、数値として扱いたい場合はas.numeric関数と組み合わせる必要があります。

シンタックス
kansuji2arabic_num(<漢数字を含む文字列>)

引数

返り値
Character

例
as.numeric(kansuji2arabic_num(漢数字の列)) 漢数字の列をアラビア数字の文字列に変換した後、数値型に変換します。

漢数字の列 数値
一 1
十二 12
百二十三 123