在试图理解一个程序时，或者在某些极端情况下，找出某个东西的类型是很有用的。我知道调试器可以向您显示一些类型信息，在这些情况下，您通常可以依靠类型推断来避免不指定类型，但我仍然希望有类似Python的type()的东西。

dynamicType(参见这个问题)

更新:在Swift的最新版本中，obj已被更改。dynamicType现在提供了对类型的引用，而不是动态类型的实例。

这款似乎最有希望，但到目前为止我还没能找到实际的型号。

class MyClass {
    var count = 0
}

let mc = MyClass()

# update: this now evaluates as true
mc.dynamicType === MyClass.self

我还尝试使用类引用来实例化一个新对象，这确实有效，但奇怪的是，给了我一个错误，说我必须添加一个必需的初始化器:

工作原理:

class MyClass {
    var count = 0
    required init() {
    }
}

let myClass2 = MyClass.self
let mc2 = MyClass2()

不过，要真正发现任何给定对象的类型，这仍然只是一小步

编辑:我已经删除了大量现在不相关的细节-如果你感兴趣，看看编辑历史:)

大多数人说永远不要从析构函数抛出异常——这样做会导致未定义的行为。Stroustrup指出，“vector析构函数显式地为每个元素调用析构函数。这意味着如果元素析构函数抛出，则vector销毁失败…实际上没有很好的方法来防止析构函数抛出异常，因此标准库不保证元素析构函数是否抛出”(摘自附录E3.2)。

这篇文章似乎不是这么说的——抛出析构函数或多或少是可以的。

所以我的问题是，如果从析构函数抛出导致未定义的行为，你如何处理析构函数期间发生的错误?

如果在清理操作期间发生错误，您会忽略它吗?如果它是一个可以在堆栈中处理但不能在析构函数中处理的错误，那么从析构函数抛出异常难道没有意义吗?

显然，这种错误很少见，但也有可能发生。

在Visual Basic中Dim代表什么?

我有一个由AnyObject组成的数组。我想遍历它，找到所有数组实例的元素。

我怎么能检查如果一个对象是一个给定的类型在Swift?

c++支持“finally”块吗?

RAII习语是什么?

c++的RAII习语和c#的using语句有什么区别?

np。einsum工作吗?

给定数组A和B，它们的矩阵乘法和转置是使用(A @ B).T计算的，或者等效地，使用:

np.einsum("ij, jk -> ki", A, B)

我不明白为什么Python没有符号函数。它有腹肌(我认为它是sign的姐妹)，但没有sign。

在python 2.6中，甚至有一个copysign函数(在数学中)，但没有符号。当你可以只写一个符号，然后直接从abs(x) * sign(y)得到copyysign时，为什么还要麻烦写一个copyysign (x,y)呢?后者会更清楚:x和y的符号，而对于copysign，你必须记住它是x和y的符号还是y和x的符号!

显然，sign(x)提供的东西比cmp(x,0)多不了什么，但它的可读性也比这强得多(对于python这样可读性很强的语言来说，这将是一个很大的优点)。

If I were a python designer, I would been the other way arond: no cmp builtin, but a sign. When you need cmp(x,y), you could just do a sign(x-y) (or, even better for non-numerical stuff, just a x>y - of course this should have required sorted accepting a boolean instead of an integer comparator). This would also be more clear: positive when x>y (whereas with cmp you have to remember the convention positive when the first is bigger, but it could be the other way around). Of course cmp makes sense in its own for other reasons (e.g. when sorting non-numerical things, or if you want the sort to be stable, which is not possible using with simply a boolean)

那么，问题是:为什么Python设计者决定将符号函数排除在语言之外?为什么要麻烦复制符号而不是它的父符号呢?

我遗漏了什么吗?

编辑-在Peter Hansen评论之后。 很好，你没有使用它，但你没有说你用python做什么。在我使用python的7年里，我需要它无数次，最后一次是压垮骆驼的最后一根稻草!

是的，你可以传递cmp，但是90%的情况下，我需要传递的是一个成语 x,y: cmp(score(x) score(y))用符号就可以了。

最后，我希望你同意sign比copysign更有用，所以即使我同意你的观点，为什么要在数学中定义它，而不是sign呢?复印签名怎么比签名有用这么多?

假设你有两个实体，玩家和团队，玩家可以在多个团队中。在我的数据模型中，每个实体都有一个表，还有一个连接表来维护这些关系。Hibernate可以很好地处理这个问题，但是我如何在RESTful API中公开这种关系呢?

我能想到几种方法。首先，我可能让每个实体都包含另一个实体的列表，所以一个Player对象将有一个它所属的Teams列表，而每个Team对象将有一个属于它的Player列表。所以要添加一个球员到一个球队，你只需要将球员的表示POST到一个端点，比如POST / Player或POST / Team，并将适当的对象作为请求的有效负载。对我来说，这似乎是最“RESTful”的，但感觉有点奇怪。

/api/team/0:

{
    name: 'Boston Celtics',
    logo: '/img/Celtics.png',
    players: [
        '/api/player/20',
        '/api/player/5',
        '/api/player/34'
    ]
}

/api/player/20:

{
    pk: 20,
    name: 'Ray Allen',
    birth: '1975-07-20T02:00:00Z',
    team: '/api/team/0'
}

我能想到的另一种方法是将关系作为其本身的资源公开。因此，要查看给定球队中所有球员的列表，您可以执行GET /playerteam/team/{id}或类似的操作，并获得一个playerteam实体的列表。要将一名球员添加到球队，POST /playerteam，并将适当构建的playerteam实体作为有效负载。

/api/team/0:

{
    name: 'Boston Celtics',
    logo: '/img/Celtics.png'
}

/api/player/20:

{
    pk: 20,
    name: 'Ray Allen',
    birth: '1975-07-20T02:00:00Z',
    team: '/api/team/0'
}

/api/player/team/0/:

[
    '/api/player/20',
    '/api/player/5',
    '/api/player/34'
]

对此的最佳实践是什么?

我需要知道Python中的变量是字符串还是字典。下面的代码有问题吗?

if type(x) == type(str()):
    do_something_with_a_string(x)
elif type(x) == type(dict()):
    do_somethting_with_a_dict(x)
else:
    raise ValueError

更新:我接受avisser的答案(尽管如果有人解释为什么isinstance比type(x) is更受欢迎，我会改变主意)。

但是感谢nakedfanatic提醒我，使用dict(作为case语句)通常比使用if/elif/else系列更简洁。

让我详细说明我的用例。如果一个变量是一个字符串，我需要把它放在一个列表中。如果是字典，我需要一个唯一值的列表。这是我想到的:

def value_list(x):
    cases = {str: lambda t: [t],
             dict: lambda t: list(set(t.values()))}
    try:
        return cases[type(x)](x)
    except KeyError:
        return None

如果isinstance是首选，你将如何编写这个value_list()函数?

c#编译器要求每当自定义类型定义operator ==时，它也必须定义!=(参见这里)。

Why?

我很好奇为什么设计人员认为这是必要的，为什么编译器不能默认为一个合理的实现操作符时，只有另一个存在。例如，Lua只允许定义相等操作符，而免费获得另一个。c#也可以做到这一点，要求你定义==或同时定义==和!=，然后自动将缺少的!=运算符编译为!(左==右)。

我知道有一些奇怪的极端情况，一些实体可能既不相等也不相等(如IEEE-754 NaN)，但这些似乎是例外，而不是规则。因此，这并不能解释为什么c#编译器设计人员将例外设置为规则。

我见过一些糟糕的情况，其中定义了相等运算符，然后不等式运算符是一个复制粘贴，每个比较都反转，每个&&切换到||(你明白了吧……(a==b)通过德摩根法则展开)。这是编译器可以通过设计消除的不良实践，就像Lua一样。

注意: 运算符< > <= >=也是如此。我无法想象在哪些情况下需要用非自然的方式来定义它们。Lua只允许您定义<和<=，并通过前两者的否定自然地定义>=和>。为什么c#不做同样的事情(至少在默认情况下)?

EDIT

显然，有充分的理由允许程序员根据自己的喜好执行相等和不相等的检查。一些答案指向了这样做可能不错的案例。

然而，我问题的核心是，为什么在c#中这是强制要求的，而通常这在逻辑上是不必要的?

It is also in striking contrast to design choices for .NET interfaces like Object.Equals, IEquatable.Equals IEqualityComparer.Equals where the lack of a NotEquals counterpart shows that the framework considers !Equals() objects as unequal and that's that. Furthermore, classes like Dictionary and methods like .Contains() depend exclusively on the aforementioned interfaces and do not use the operators directly even if they are defined. In fact, when ReSharper generates equality members, it defines both == and != in terms of Equals() and even then only if the user chooses to generate operators at all. The equality operators aren't needed by the framework to understand object equality.

基本上，. net框架并不关心这些操作符，它只关心一些Equals方法。要求用户同时定义==和!=操作符的决定纯粹与语言设计有关，而与. net关心的对象语义无关。