众所周知，nan在算术中传播，但我找不到任何演示，所以我写了一个小测试:

#include <limits>
#include <cstdio>

int main(int argc, char* argv[]) {
    float qNaN = std::numeric_limits<float>::quiet_NaN();

    float neg = -qNaN;

    float sub1 = 6.0f - qNaN;
    float sub2 = qNaN - 6.0f;
    float sub3 = qNaN - qNaN;

    float add1 = 6.0f + qNaN;
    float add2 = qNaN + qNaN;

    float div1 = 6.0f / qNaN;
    float div2 = qNaN / 6.0f;
    float div3 = qNaN / qNaN;

    float mul1 = 6.0f * qNaN;
    float mul2 = qNaN * qNaN;

    printf(
        "neg: %f\nsub: %f %f %f\nadd: %f %f\ndiv: %f %f %f\nmul: %f %f\n",
        neg, sub1,sub2,sub3, add1,add2, div1,div2,div3, mul1,mul2
    );

    return 0;
}

这个例子(在这里运行)基本上产生了我所期望的(否定是有点奇怪，但它是有道理的):

neg: -nan
sub: nan nan nan
add: nan nan
div: nan nan nan
mul: nan nan

MSVC 2015也产生了类似的东西。然而，Intel c++ 15产生:

neg: -nan(ind)
sub: nan nan 0.000000
add: nan nan
div: nan nan nan
mul: nan nan

具体来说，qNaN - qNaN == 0.0。

这个…不可能是对的，对吧?相关标准(ISO C, ISO c++， IEEE 754)对此做了什么说明，为什么编译器之间的行为有差异?

为什么NaN值的比较与所有其他值的比较行为不同? 也就是说，与运算符==，<=，>=，<，>的所有比较，其中一个或两个值都是NaN，返回false，与所有其他值的行为相反。

我认为这在某种程度上简化了数值计算，但我找不到一个明确的原因，甚至在Kahan的《IEEE 754状态讲义》中也找不到，他详细讨论了其他设计决策。

在进行简单的数据处理时，这种异常行为会造成麻烦。例如，当在C程序中对记录列表w.r.t.某个实值字段进行排序时，我需要编写额外的代码来处理NaN作为最大元素，否则排序算法可能会变得混乱。

编辑: 到目前为止，所有的答案都认为比较nan是没有意义的。

我同意，但这并不意味着正确答案是错误的， 而是一个非布尔型(NaB)，幸运的是它并不存在。

所以在我看来，选择返回真或假进行比较是随意的， 对于一般的数据处理来说，如果它符合通常的规律，那将是有利的 (==的反身性，<，==，>的三分)， 以免依赖这些定律的数据结构变得混乱。

所以我要求的是打破这些定律的一些具体好处，而不仅仅是哲学推理。

编辑2: 我想我现在明白为什么让NaN最大是一个坏主意了，它会搞砸上限的计算。

NaN != NaN可能是可取的，以避免检测循环中的收敛，例如

while (x != oldX) {
    oldX = x;
    x = better_approximation(x);
}

但是最好是通过比较小极限下的绝对差来写。 所以恕我直言，这是一个相对较弱的论点，打破自反性在NaN。

我得到一个错误

列的员工。EmpID'在选择列表中无效，因为它是无效的 不包含在聚合函数或GROUP BY子句中。

---

select loc.LocationID, emp.EmpID
from Employee as emp full join Location as loc 
on emp.LocationID = loc.LocationID
group by loc.LocationID 

这种情况符合Bill Karwin给出的答案。

修正以上，符合ExactaBox -的答案

select loc.LocationID, count(emp.EmpID) -- not count(*), don't want to count nulls
from Employee as emp full join Location as loc 
on emp.LocationID = loc.LocationID
group by loc.LocationID 

---

原来的问题

对于SQL查询-

select *
from Employee as emp full join Location as loc 
on emp.LocationID = loc.LocationID
group by (loc.LocationID)

我不明白为什么会得到这个错误。我所要做的就是连接这些表，然后将所有员工分组在一个特定的位置。

对于我自己的问题，我想我有一个部分的解释。告诉我是否可以

为了对在同一位置工作的所有员工进行分组，我们必须首先提到LocationID。

然后，我们不能/不提到它旁边的每个员工ID。相反，我们提到该位置的员工总数，即我们应该SUM()在该位置工作的员工。我不知道为什么我们要用后一种方式。 因此，这就解释了“它不包含在任何一个聚合函数中”这部分错误。

如何解释错误的GROUP BY子句部分?

当在一个模型-视图-视图模型架构的WPF应用程序中实现ViewModel时，似乎有两个主要的选择:如何使它可数据化。我已经看到实现使用DependencyProperty属性的视图要绑定，我已经看到ViewModel实现INotifyPropertyChanged代替。

我的问题是，什么时候我应该更喜欢其中一个?有什么性能差异吗?把ViewModel依赖项交给WPF真的是个好主意吗?在做设计决定时，我还需要考虑什么?

文档展示了如何在一个groupby对象上同时应用多个函数，使用输出列名作为键的dict:

In [563]: grouped['D'].agg({'result1' : np.sum,
   .....:                   'result2' : np.mean})
   .....:
Out[563]: 
      result2   result1
A                      
bar -0.579846 -1.739537
foo -0.280588 -1.402938

但是，这只适用于Series groupby对象。当dict类似地通过DataFrame传递给一个组时，它期望键是函数将应用到的列名。

What I want to do is apply multiple functions to several columns (but certain columns will be operated on multiple times). Also, some functions will depend on other columns in the groupby object (like sumif functions). My current solution is to go column by column, and doing something like the code above, using lambdas for functions that depend on other rows. But this is taking a long time, (I think it takes a long time to iterate through a groupby object). I'll have to change it so that I iterate through the whole groupby object in a single run, but I'm wondering if there's a built in way in pandas to do this somewhat cleanly.

例如，我曾经尝试过

grouped.agg({'C_sum' : lambda x: x['C'].sum(),
             'C_std': lambda x: x['C'].std(),
             'D_sum' : lambda x: x['D'].sum()},
             'D_sumifC3': lambda x: x['D'][x['C'] == 3].sum(), ...)

但正如预期的那样，我得到一个KeyError(因为键必须是一列，如果agg从一个DataFrame调用)。

是否有任何内置的方式来做我想做的事情，或者这种功能可能会被添加，或者我只需要手动遍历组?

多年来，我一直在对所有类型的聚合查询使用GROUP BY。最近，我一直在逆向工程一些使用PARTITION BY来执行聚合的代码。

在阅读我能找到的所有关于PARTITION BY的文档时，它听起来很像GROUP BY，可能还添加了一些额外的功能。

它们是相同功能的两个版本还是完全不同的东西?

我有一个类似调用者makerar的表格

 cname  | wmname |          avg           
--------+-------------+------------------------
 canada | zoro   |     2.0000000000000000
 spain  | luffy  | 1.00000000000000000000
 spain  | usopp  |     5.0000000000000000

我想为每个cname选择最大的avg。

SELECT cname, wmname, MAX(avg)  FROM makerar GROUP BY cname;

但是我会得到一个错误，

ERROR:  column "makerar.wmname" must appear in the GROUP BY clause or be used in an   aggregate function 
LINE 1: SELECT cname, wmname, MAX(avg)  FROM makerar GROUP BY cname;

所以我这样做

SELECT cname, wmname, MAX(avg)  FROM makerar GROUP BY cname, wmname;

然而，这不会给出预期的结果，下面显示了不正确的输出。

 cname  | wmname |          max           
--------+--------+------------------------
 canada | zoro   |     2.0000000000000000
 spain  | luffy  | 1.00000000000000000000
 spain  | usopp  |     5.0000000000000000

实际结果应为

 cname  | wmname |          max           
--------+--------+------------------------
 canada | zoro   |     2.0000000000000000
 spain  | usopp  |     5.0000000000000000

我该如何着手解决这个问题呢?

注意:这个表是在前面的操作中创建的VIEW。

我读过关于双精度和单精度之间的区别。然而，在大多数情况下，float和double似乎是可互换的，即使用其中一个似乎不会影响结果。事实真的如此吗?什么时候浮点数和双精度数可以互换?它们之间有什么区别?

I keep seeing "bootstrapping" mentioned in discussions of application development. It seems both widespread and important, but I've yet to come across even a poor explanation of what bootstrapping actually is; rather, it seems as though everyone is just supposed to know what it means. I don't, though. Near as I can figure, it has something to do with initialization tasks required of an application upon launch, but I could be completely wrong about that. Can anyone help me to understand this idea?

我有一张文件表（此处为简化版）：

如何为每个id选择一行，并且仅选择最大的rev？对于上面的数据，结果应该包含两行：[1，3，…]和[2，1，…]。我使用的是MySQL。

目前，我在while循环中使用检查来检测和重写结果集中的旧版本。但这是实现结果的唯一方法吗？没有SQL解决方案吗？