用数字 (1 / 0) 替换逻辑值 (TRUE / FALSE)

Posted 2023-02-25

【中文标题】用数字 (1 / 0) 替换逻辑值 (TRUE / FALSE)

【英文标题】：Replace logical values (TRUE / FALSE) with numeric (1 / 0)

【发布时间】：2015-09-05 17:36:00

【问题描述】：

我正在使用以下命令从 R 导出数据：

write.table(output,file = "data.raw", na "-9999", sep = "\t", row.names = FALSE, col.names = FALSE)

它可以正确导出我的数据，但会将所有逻辑变量导出为TRUE 和FALSE。

我需要将数据读入另一个只能处理数值的程序。有没有一种有效的方法可以在导出过程中将logical 列转换为数字 1 和 0？我有大量的数值变量，所以我希望能自动循环遍历data.table中的所有变量

或者，我的输出对象是data.table。有没有一种有效的方法将data.table 中的所有逻辑变量转换为数值变量？

如果有帮助，这里有一些代码可以生成一个data.table，其中包含一个逻辑变量（它不是大量的逻辑变量，但足以在示例代码中使用）：

DT = data.table(cbind(1:100, rnorm(100) > 0)
DT[ , V3:= V2 == 1 ]
DT[ , V4:= V2 != 1 ]

【问题讨论】：

您询问了效率，所以：as.integer 可能比as.numeric 快 3 倍（以下所有答案都使用）。我试过了：x <- sample(c(TRUE,FALSE,NA),1e8,replace=TRUE); system.time("+"(x)); system.time(as.integer(x)); system.time(as.numeric(x))

@Frank 谢谢，我想知道为什么每个人都在使用as.numeric——我认为as.integer 会更快，因为存储要求更小...

@MichaelChirico 您对as.integer 的看法是正确的。使用data.table，如果您使用mean 左右更改该列中的某些值，则会出现'class.否则，使用value=dat[[j]]+0L)

会更容易

最短的是+A。

【参考方案1】：

只是一个：

dat <- data.frame(le = letters[1:10], lo = rep(c(TRUE, FALSE), 5))
dat
   le    lo
1   a  TRUE
2   b FALSE
3   c  TRUE
4   d FALSE
5   e  TRUE
6   f FALSE
7   g  TRUE
8   h FALSE
9   i  TRUE
10  j FALSE
dat$lo <- as.numeric(dat$lo)
dat
   le lo
1   a  1
2   b  0
3   c  1
4   d  0
5   e  1
6   f  0
7   g  1
8   h  0
9   i  1
10  j  0

如果情况（没人知道）您的数据将被导入 R，则可以使用 dplyr 来保留前一列。

library(dplyr)
dat <- dat %>% mutate(lon = as.numeric(lo))
dat
Source: local data frame [10 x 3]

   le    lo lon
1   a  TRUE   1
2   b FALSE   0
3   c  TRUE   1
4   d FALSE   0
5   e  TRUE   1
6   f FALSE   0
7   g  TRUE   1
8   h FALSE   0
9   i  TRUE   1
10  j FALSE   0

编辑：循环

我不知道我的代码是否正在执行，但它会检查所有列并仅将那些符合逻辑的列更改为数字。当然，如果您的 TRUE 和 FALSE 不合逻辑但字符串（可能是远程的）我的代码将无法工作。

for(i in 1:ncol(dat))

    if(is.logical(dat[, i]) == TRUE) dat[, i] <- as.numeric(dat[, i]) 

    

【参考方案2】：

对于 data.frame，您可以使用以下命令将所有逻辑列转换为数字：

# The data
set.seed(144)
dat <- data.frame(V1=1:100,V2=rnorm(100)>0)
dat$V3 <- dat$V2 == 1
head(dat)
#   V1    V2    V3
# 1  1 FALSE FALSE
# 2  2  TRUE  TRUE
# 3  3 FALSE FALSE
# 4  4 FALSE FALSE
# 5  5 FALSE FALSE
# 6  6  TRUE  TRUE

# Convert all to numeric
cols <- sapply(dat, is.logical)
dat[,cols] <- lapply(dat[,cols], as.numeric)
head(dat)
#   V1 V2 V3
# 1  1  0  0
# 2  2  1  1
# 3  3  0  0
# 4  4  0  0
# 5  5  0  0
# 6  6  1  1

在data.table 语法中：

# Data
set.seed(144)
DT = data.table(cbind(1:100,rnorm(100)>0))
DT[,V3 := V2 == 1]
DT[,V4 := FALSE]
head(DT)
#    V1 V2    V3    V4
# 1:  1  0 FALSE FALSE
# 2:  2  1  TRUE FALSE
# 3:  3  0 FALSE FALSE
# 4:  4  0 FALSE FALSE
# 5:  5  0 FALSE FALSE
# 6:  6  1  TRUE FALSE

# Converting
(to.replace <- names(which(sapply(DT, is.logical))))
# [1] "V3" "V4"
for (var in to.replace) DT[, (var):= as.numeric(get(var))]
head(DT)
#    V1 V2 V3 V4
# 1:  1  0  0  0
# 2:  2  1  1  0
# 3:  3  0  0  0
# 4:  4  0  0  0
# 5:  5  0  0  0
# 6:  6  1  1  0

【参考方案3】：

如果有多个列，您可以使用set（使用@josilber 的示例）

library(data.table)
Cols <-  which(sapply(dat, is.logical))
setDT(dat)

for(j in Cols)
 set(dat, i=NULL, j=j, value= as.numeric(dat[[j]]))

【讨论】：

谢谢，这也很好用，我不知道set 命令。

@johneric set 会非常快。查看帮助页面?set

【参考方案4】：

作为Ted Harding pointed out in the R-help mailing list，将逻辑对象转换为数字的一种简单方法是对它们执行算术运算。方便的是 * 1 和 + 0，它们将保持 TRUE/FALSE == 1/0 范式。

对于您的模拟数据（我已经稍微更改了代码以使用常规 R 包并减小大小）：

df    <- data.frame(cbind(1:10, rnorm(10) > 0))
df$X3 <- df$X2 == 1
df$X4 <- df$X2 != 1

您获得的数据集混合了数字和布尔变量：

   X1 X2    X3    X4
1   1  0 FALSE  TRUE
2   2  0 FALSE  TRUE
3   3  1  TRUE FALSE
4   4  1  TRUE FALSE
5   5  1  TRUE FALSE
6   6  0 FALSE  TRUE
7   7  0 FALSE  TRUE
8   8  1  TRUE FALSE
9   9  0 FALSE  TRUE
10 10  1  TRUE FALSE

现在让

df2 <- 1 * df

（如果您的数据集包含字符或因子变量，则需要将此操作应用于df 的子集，过滤掉这些变量）

df2 等于

   X1 X2 X3 X4
1   1  0  0  1
2   2  0  0  1
3   3  1  1  0
4   4  1  1  0
5   5  1  1  0
6   6  0  0  1
7   7  0  0  1
8   8  1  1  0
9   9  0  0  1
10 10  1  1  0

这是 100% 的数字，str(df2) 会告诉你。

现在您可以安全地将df2 导出到您的其他程序。

【参考方案5】：

最简单的方法！

将矩阵乘以 1

例如：

A <- matrix(c(TRUE,FALSE,TRUE,TRUE,TRUE,FALSE,FALSE,TRUE),ncol=4)
A

#       [,1] [,2]  [,3]  [,4]
# [1,]  TRUE TRUE  TRUE FALSE
# [2,] FALSE TRUE FALSE  TRUE

B <- 1*A
B
#      [,1] [,2] [,3] [,4]
# [1,]    1    1    1    0
# [2,]    0    1    0    1

（你也可以加零：B <- 0 + A）

【讨论】：

不仅最简单，而且最快。

【参考方案6】：

一线解决方案

使用以下代码，我们获取所有逻辑列并将它们设为数字。

library(magrittr)
dat %<>% mutate_if(is.logical,as.numeric) 

【讨论】：

还有mutate(across(where(is.logical), as.numeric))

就是这样。

【参考方案7】：

与@saebod 相同，但使用普通管道。

图书馆(dplyr) dat % mutate_if(is.logical, as.numeric)