小编Fab*_*ner的帖子

这很奇怪:R ifelse()似乎做了一些(不需要的)转换:假设我有一个时间戳矢量(可能是NA),NA值应该与现有日期区别对待,例如,只是忽略:

formatString = "%Y-%m-%d %H:%M:%OS"
timestamp = c(as.POSIXct(strptime("2000-01-01 12:00:00.000000", formatString)) + (1:3)*30, NA)

现在

timestamp
#[1] "2000-01-01 12:00:30 CET" "2000-01-01 12:01:00 CET" "2000-01-01 12:01:30 CET"
#[6] NA    

根据需要,但翻译30秒会导致

ifelse(is.na(timestamp), NA, timestamp+30)
#[1] 946724460 946724490 946724520        NA

请注意,仍然timestamp+30按预期工作,但我想说我想用固定日期替换NA日期,并将所有其他日期翻译30秒:

fixedDate = as.POSIXct(strptime("2000-01-01 12:00:00.000000", formatString))
ifelse(is.na(timestamp), fixedDate, timestamp+30)
#[1] 946724460 946724490 946724520 946724400

问题:这个解决方案有什么问题,为什么它没有按预期工作？

编辑:所需的输出是30秒转换的时间戳(不是整数)的向量,NA被替换为...

我试图弄清楚熊猫数据框中的列是否是布尔值（如果是，是否有缺失值等等）。

为了测试我创建的函数，我尝试创建一个带有缺失值的布尔列的数据框。但是，我会说缺失值在 python 中完全“无类型”处理，并且有一些奇怪的行为：

> boolean = pd.Series([True, False, None])
> print(boolean)

0     True
1    False
2     None
dtype: object

因此，当您将 None 放入列表时，它被视为对象，因为 python 无法将类型 bool 和 type(None)=NoneType 混合回 bool。math.nan和也会发生同样的事情numpy.nan。当你试图强迫熊猫进入它不想去的区域时，最奇怪的事情发生了:-)

> boolean = pd.Series([True, False, np.nan]).astype(bool)
> print(boolean)
0     True
1    False
2     True
dtype: bool

所以'np.nan'被转换为'True'？

问题：

1. 给定一个数据表，其中一列是“对象”类型，但实际上它是一个带有缺失值的布尔列：我如何弄清楚？过滤非缺失值后，它仍然是“对象”类型……我是否需要将每一列的 try-catch-cast 实现为每个可以想象的数据类型，以便查看列的真实性质？

2. 我想对于为什么 np.nan 被强制转换为 True 有一个合乎逻辑的解释，但这是软件 pandas/python 本身不需要的行为，对吗？那么我应该提交错误报告吗？

我一直很高兴地使用R进行数据分析。通过数据分析，我的意思是：给定一个相对较小的表（<1 mio行，<100列），回答有关数据的“复杂”问题，例如“对于每个实例，在特定时间点变化之前发生的最后一个事件是什么？与实例”等等。

最近，我被置于人们使用python的环境中。据我所知，做这些事情的唯一包装是熊猫。尽管尝试过，但仍在（几周后）努力进行最简单的操作。让我们考虑一下这种情况：我正在查看由按SORT_NR列排序的不同事件组成的进程（由PROC_ID列标识）。出于某种奇怪的原因，我想执行以下操作：给定固定的进程ID proc_id，我想向所有SORT_NR添加一定的数字“ add”，以使SORT_NR> = start成为固定参数start。例：

PROC_ID | SORT_NR
      A |       1
      A |       2
      A |       3
      A |       4
      A |       5
      B |       1
      B |       2

我现在使用proc_id = A，start = 3，add = 2调用此函数，这意味着预期结果将是

PROC_ID | SORT_NR
      A |       1
      A |       2
      A |       5 <<< 2 was added
      A |       6 <<< 2 was added
      A |       7 <<< 2 was added
      B |       1
      B |       2

谷歌搜索给了我答案，这可以通过

df.loc [（df ['PROC_ID'] == proc_id）＆（df …

我有以下情况:

1)数据表列表

2)出于测试目的,我故意(深入)复制整个列表,包括数据表

3)我想从复制的列表中取一些元素并添加一个新列.

这是代码:

library(data.table)
x = data.table(aaa = c(1,2))
y = data.table(bbb = c(1,2))
z = list(x,y)
zz = copy(z)

v = zz[[1]]
v = v[, newColumn := 1]

现在我收到以下错误:

Error in `[.data.table`(res, , `:=`(xxx, TRUE)) : 
(converted from warning) Invalid .internal.selfref detected and fixed
by taking a copy of the whole table so that := can add this new column 
by reference. At an earlier point, this data.table has been copied by R 
(or been …

我正在使用很棒的 R data.table 包。然而，访问（即通过引用操作）具有变量名的列非常笨拙：如果给定一个dt具有两列 x 和 y 的 data.table，并且我们想要添加两列并将其命名为 z，那么命令是

dt = dt[, z := x + y]

现在让我们编写一个函数，它以 data.table和三个列名add作为参数，并且假设仅使用通用列名执行与上面完全相同的命令。我现在使用的解决方案是反射，即dtsummand1Namesummand2NameresultName

add = function(dt, summand1Name, summand2Name, resultName) {
  cmd = paste0('dt = dt[, ', resultName, ' := ', summand1Name, ' + ', summand2Name, ']')
  eval(parse(text=cmd))
  return(dt) # optional since manipulated  by reference
}

但是我对这个解决方案绝对不满意。首先，它很笨拙，这样的代码没有乐趣。它很难调试，而且只会让我生气并浪费时间。其次，它更难阅读和理解。这是我的问题：

我们可以用更好的方式编写这个函数吗？

我知道这样一个事实，即可以像这样访问具有变量名称的列：dt[[resultName]]但是当我写

dt[[resultName]] = dt[[summand1Name]] + dt[[summand2Name]]

然后 data.table 开始抱怨已获取副本并且无法通过引用工作。我不想要这样。我也喜欢这种语法dt = dt[<all 'database related operations'>]，这样我所做的一切都被放在一对括号中。是否可以使用反引号等特殊符号来指示当前使用的名称不是引用数据表的实际列，而是实际列名称的占位符？

我在名为“ circular_dependency”的目录中有一些python文件：

import_file_1.py：

from circular_dependency.import_file_2 import *

def add_one(x):
    return x+1

import_file_2.py：

from circular_dependency.import_file_1 import *

def add_two(x):
    return add_one(add_one(x))

最后是main.py

from circular_dependency.import_file_1 import *
from circular_dependency.import_file_2 import *

x = 17
print(add_two(x))

运行main.py会导致以下错误：

/Users/fabianwerner/anaconda3/envs/academy/bin/python /Users/fabianwerner/BI-X/academy/exercises/01_exMON_python/circular_dependency/main.py
Traceback (most recent call last):
  File "/Users/fabianwerner/BI-X/academy/exercises/01_exMON_python/circular_dependency/main.py", line 5, in <module>
    print(add_two(x))
  File "/Users/fabianwerner/BI-X/academy/exercises/01_exMON_python/circular_dependency/import_file_2.py", line 4, in add_two
    return add_one(add_one(x))
NameError: name 'add_one' is not defined

Process finished with exit code 1

据我了解，python并不能很好地应对循环（嗯，实际上是无害的）“循环”依赖关系。因此，当python抱怨我已经创建了循环依赖的事实时，我会想到一个错误。

->问题：

1. 为什么python不抱怨循环依赖？
2. 以下错误是什么意思？为什么add_twoimport_file_2.py中的函数add_one无法从import_file_1.py中找到该函数，但是我已经导入了该函数？

感谢您清理此问题:-)

注意:我对"只使用for for循环"这个形式的答案不感兴趣,我想以笨拙的方式做到这一点.

我是Python的初学者,我想使用numpy ndarray执行以下操作:给定一个数字t序列和另一个数字序列b,对于每个t[i]我想要计算列表t[i]*b并将其存储为最终数组中的新行.例:

t = [3,4]
b = [1,2,3,4]

然后结果应该是某种形式的列表编码

[
  [3,6,9,12], # 3 * the array of b's
  [4,8,12,16]   # 4 * the array of b's
]

在我最近看到的一个程序中,这完全成功,但是当我想自己做的时候,它会引发一个错误:运行

import numpy

t = numpy.linspace(3,4,2)[:, None]
t = t.T

# filled with some garbage numbers
b = numpy.ndarray(shape=(4,1), dtype=numpy.float64, order='C')

res = numpy.dot(t,b)

在python(版本3.4)给出

Traceback (most recent call last):
  File "C:\Daten\LiClipse_workspace\TestProject\MainPackage\PlayGround.py", line 9, in <module>
    res = numpy.dot(t,b)
ValueError: shapes (1,2) and …