相关疑难解决方法(0)

相关的IEEE标准定义了一个数字常量NaN(不是数字),并规定NaN应该比较为不等于它自己.这是为什么？

我熟悉的所有语言都实现了这个规则.但它经常会导致严重的问题,例如当NaN存储在容器中时,NaN存在于正在排序的数据中等时的意外行为等.更不用说,绝大多数程序员都希望任何对象都等于自身(在他们了解NaN之前,令人惊讶的是他们增加了错误和混乱.

IEEE标准经过深思熟虑,因此我确信NaN的比较与其本身相同是很糟糕的.我只是想不通它是什么.

可以说我有以下内容pandas DataFrame:

import pandas as pd
df = pd.DataFrame({"A":[1,pd.np.nan,2], "B":[5,6,0]})

看起来像这样:

>>> df
     A  B
0  1.0  5
1  NaN  6
2  2.0  0

第一种选择

我知道一种方法来检查特定值是否NaN为,如下所示:

>>> df.isnull().ix[1,0]
True

第二种选择(不工作)

我认为下面的选项,使用ix,也可以,但它不是:

>>> df.ix[1,0]==pd.np.nan
False

我也尝试iloc过相同的结果:

>>> df.iloc[1,0]==pd.np.nan
False

但是,如果我使用ix或检查这些值iloc:

>>> df.ix[1,0]
nan
>>> df.iloc[1,0]
nan

那么,为什么第二种选择不起作用呢？是否可以NaN使用ix或检查值iloc？

我想是的

data[data.agefm.isnull()]

和

data[data.agefm == numpy.nan]

是等价的.但不,第一个真正返回agefm为NaN的行,但第二个返回一个空的DataFrame.我感谢省略的值总是等于np.nan,但似乎错了.

agefm列有float64类型:

(Pdb) data.agefm.describe()
count    2079.000000
mean       20.686388
std         5.002383
min        10.000000
25%        17.000000
50%        20.000000
75%        23.000000
max        46.000000
Name: agefm, dtype: float64

你能解释一下,具体data[data.agefm == np.nan]意味着什么？

在我的for循环中,我的代码生成了一个像这样的列表:

list([0.0,0.0]/sum([0.0,0.0]))

循环生成所有类型的其他数字向量,但它也生成[nan,nan],并且为了避免它我试图放入条件以防止它像下面的那个,但它不会返回true.

nan in list([0.0,0.0]/sum([0.0,0.0]))
>>> False

它不应该归还吗？

我加载的库:

import PerformanceAnalytics as perf
import DataAnalyticsHelpers
import DataHelpers as data
import OptimizationHelpers as optim
from matplotlib.pylab import *
from pandas.io.data import DataReader
from datetime import datetime,date,time
import tradingWithPython as twp
import tradingWithPython.lib.yahooFinance as data_downloader # used to get data from yahoo finance
import pandas as pd # as always.
import numpy as np
import zipline as zp
from scipy.optimize import minimize
from itertools import product, combinations
import time …

在Python Pandas和Numpy中，比较结果为何不同？

from pandas import Series
from numpy import NaN

NaN 不等于 NaN

>>> NaN == NaN
False

但NaN在列表或元组中是

>>> [NaN] == [NaN], (NaN,) == (NaN,)
(True, True)

而Series与NaN又不相等：

>>> Series([NaN]) == Series([NaN])
0    False
dtype: bool

和None：

>>> None == None, [None] == [None]
(True, True)

而

>>> Series([None]) == Series([None])
0    False
dtype: bool 

这个答案解释了原因NaN == NaN是False一般，但并没有解释其在python /大熊猫收藏行为。

我试图比较两个不同的列表以查看它们是否相等，并且打算删除NaN，但发现我的列表比较仍然有效，尽管NaN == NaN -> False。

有人可以解释为什么下面的结果为True或False，因为我发现此行为是意外的。谢谢，

我已阅读以下内容，似乎无法解决该问题：

• 为什么在nan == nan[num]中的nan为True时，在numpy中为False？
• 为什么NaN不等于NaN？[重复]

（Python 2.7.3，numpy-1.9.2）

我用*结尾标记了令人惊讶的评估

>>> nan = np.nan
>>> [1,2,3]==[3]
False
>>> [1,2,3]==[1,2,3]
True
>>> [1,2,nan]==[1,2,nan]
True ***
>>> nan == nan
False
>>> [nan] == [nan]
True ***
>>> [nan, nan] == [nan for i in range(2)]
True ***
>>> [nan, nan] == [float(nan) for i in range(2)]
True ***
>>> float(nan) is (float(nan) + 1)
False
>>> float(nan) …

我有这个人.python中的字典:

OrderedDict([(30, ('A1', 55.0)), (31, ('A2', 125.0)), (32, ('A3', 180.0)), (43, ('A4', nan))])

有没有办法删除任何值为NaN的条目？我试过这个:

{k: dict_cg[k] for k in dict_cg.values() if not np.isnan(k)}

如果soln适用于python 2和python 3,那将会很棒

请你们帮我解释一下下面的代码：

为什么 anan不是np.nan？

import pandas as pd
import numpy as np

df.iloc[31464]['SalesPersonID']
[out]:
nan

df.iloc[31464]['SalesPersonID'] is np.nan
[out]:
False

谢谢你们。

假设我有以下pandas.Series:

import pandas as pd
s = pd.Series([1,3,5,True,6,8,'findme', False])

我可以使用in运算符来查找任何整数或布尔值.例子,以下全部产生True:

1 in s
True in s

但是,当我这样做时,这会失败:

'findme' in s

我的解决方法是使用pandas.Series.str或首先将Series转换为列表,然后使用in运算符:

True in s.str.contains('findme')
s2 = s.tolist()
'findme' in s2

知道为什么我不能直接使用in运算符来查找系列中的字符串吗？

Python的集合与NaNs(现在直播)的行为令人费解(至少对我而言):

>>> float('nan') in {float('nan')}    # example 1
False
>>> nan = float('nan')                # example 2
>>> nan in {nan}
True

起初,我错误地认为,这是==-operator 的行为,但显然不是这种情况,因为两种情况都False按预期产生(这里是实时的):

>>> float('nan') == float('nan') 
False
>>> nan = float('nan')
>>> nan == nan
False

我主要对这种行为的原因感兴趣.但是如果有办法确保一致的行为,那也很高兴知道!

当我检查Python操作数的相等性和身份时，例如，a = []; b = a我得到了：

a == b => True
a is b => True

我了解。

所以，为什么我用np.nan得到差异结果？：

a = np.nan; b = a 
a == b => False
a is b => True

？