小编Lif*_*ang的帖子

众所周知，classPython 中创建 new 时有很多工作是在幕后完成的，例如设置__dict__、__class__、__metaclass__等属性。

我知道，当创建一个新类时，该type.__new__方法将被调用，并且type.__init__也会在call.__new__返回type. 所以我猜这两种方法可能负责一些工作，但我在文档中找不到关于它们实际功能的任何描述。我的问题是，这两种方法到底是做什么用的class？

编辑：

我知道元类是什么以及元类在创建实例的过程中大致做了什么type，但我想知道这两种方法如何配合来完成创建实例的工作type。也许@BrenBarn 是对的，这与实现相关。我只是想确认一下。例如，如果我__new__在自己的元类中重写该方法，并直接T返回，而不是像人们通常所做的那样在基类中调用，那么既不会被调用，也不会被调用，因为返回的对象不是 的实例。如果是这样，由于缺少 ，我会错过什么 ？而且，我可以期望这在各种实现中都是一致的行为吗？type(clsname, bases, dct)__new__typeT.__init__type.__init__T__init__

我是Scala的新手.当我通过阅读其他人编写的Scala代码来学习它时,我在Scala代码中发现的与其他语言不同的一个最显着特征是它的模式匹配.

与此同时,我感受到它带来的便利性和表现力,我不禁对它背后的潜在性能成本感到好奇 - 一般来说,速度有多快match？

首先,没有"高级"功能,例如匹配构造函数的参数,match在Scala,IMO中,是switch-case其他语言的对应物.例如,

color match {
  0 => println "color is red!"
  1 => println "color is green!"
  2 => println "color is blue!"
}

作为一个新手,我想知道上面的代码是否与if-else语句中的等效代码一样快？

其次,现在恢复这些"高级"功能,例如:

expr match {
  Animal(name) => ...
  Animal(name, age) => ...
  Animal(_, _, id) => ...
}

至于上面的代码或匹配的其他功能(列表匹配,配对匹配等),我很好奇Scala如何实现这些花哨的用法？最重要的是,我能期望这些代码有多快？(比方说,它们仍然和match第一种情况一样快吗？或者可能稍微慢一些？或者由于使用某些技术如反射而极慢？)

提前致谢!

特定

scala> def method(x: Int) = x
method: (x: Int)Int

scala> val func = (x: Int) => x
func: Int => Int = <function1>

请考虑以下代码:

scala> method _
res0: Int => Int = <function1>

scala> func(_)
res1: Int => Int = <function1>

scala> func _
res2: () => Int => Int = <function0>

我可以理解,这res0是eta扩展,res1相当于lambda函数(x) => func(x).但我无法弄清楚输出res2.谁有人可以帮我解释一下？

我想创建一个变量使用tf.get_variable,它应该用numpy数组初始化.

据我所知,有两种方法可以创建变量,tf.Variable和tf.get_variable.我们可以轻松地将初始值传递给由其创建的变量tf.Variable.但似乎没有直接的方法可以对那些创造的人做同样的事情tf.get_variable.

我现在一直在做的是首先使用numpy数组创建一个张量,tf.convert_to_tensor然后将此张量作为initializerto 传递tf.get_variable.但这对我来说似乎没有用,因为我有一个非常大的数组作为初始值,然后我必须在我的图中存储这个大数组两次.

因此,我想知道是否有更有效的方法可以做到这一点？是用Variable唯一的方法来避免我上面提到的效率问题？

对于以下代码段:

struct Test
{
    public override string ToString()
    {
        return "";
    }
}

public class Program
{
    public static void Main()
    {
        Test a = new Test();
        a.ToString();
        Int32 b = 5;
        b.ToString();
    }
}

编译器发出以下IL:

  .locals init ([0] valuetype ConsoleApplication2.Test a,
           [1] int32 b)
  IL_0000:  nop
  IL_0001:  ldloca.s   a
  IL_0003:  initobj    ConsoleApplication2.Test
  IL_0009:  ldloca.s   a
  IL_000b:  constrained. ConsoleApplication2.Test
  IL_0011:  callvirt   instance string [mscorlib]System.Object::ToString()
  IL_0016:  pop
  IL_0017:  ldc.i4.5
  IL_0018:  stloc.1
  IL_0019:  ldloca.s   b
  IL_001b:  call       instance string [mscorlib]System.Int32::ToString()
  IL_0020:  pop …

根据C++标准：

\n

如果 A 的值用作 B 的操作数，则求值 A 具有对求值 B 的依赖性，除非：

\n

\xe2\x80\x94 B 是 std::kill_dependency (29.3) 的任何特化的调用，或者

\n

\xe2\x80\x94 A 是内置逻辑 AND（&&，参见 5.14）或逻辑 OR（||，参见 5.15）运算符的左操作数，或者

\n

\xe2\x80\x94 A 是条件（?:，参见 5.16）运算符的左操作数，或者

\n

\xe2\x80\x94 A 是内置逗号 (,) 运算符的左操作数 (5.18)；（...）

\n

我可以理解为什么关系之前排序的依赖项会在kill_dependency调用时停止，但是为什么逻辑AND、OR、逗号等运算符也会破坏依赖链？

这是否意味着下面的代码有未定义的行为？

//thread1\nint y = 2\natomicVal.store(true);\n\n//thread2 \nauto x = atomicVal.load(std::memory_order_consume);\ncout << x && y;\n

在Scala中,有四种成员修改,即def,val,lazy val,var.关于覆盖的规则看似复杂且不一致,例如,def可以被覆盖val,而不是相反.很高兴看到所有这些规则的完整列表.

我试图使用Newton Json反序列化器反序列化json对象,如下所示:

{
  "grades": 97
}

Or this:

{
  "grades": ""
}

我想知道如何在C#中正确定义DTO类来表示这个对象？谢谢!

编写以下代码是否安全？

private static readonly IReadOnlyDictionary<string, string> Map = new Dictionary<string, string>
{
    ["A"] = "AAA",
    ["B"] = "BBB",
    ["C"] = "CCC"
};

我知道ConcurrencyDictionary是实现字典线程安全的标准方法.但是,由于我需要的是一个"常量"映射,我从不打算修改它,初始化一个只读的IReadOnlyDictionary静态字段是否100%安全？

我是新学习者.我刚刚使用Tensorflow实现了CNN,并在CIFAR-10(一个对象识别基准测试,其中图像在10个不同的类中)上进行了尝试.

在训练过程中,训练损失在开始时(从100000到3)真的很快下降,但随后它总是停留在2.30左右(大约是log(1/10)).由于我使用交叉熵作为损失函数,因此损失2.30意味着我的模型具有大约10%的准确度----与随机猜测完全相同(我已经检查了模型的实际输出,实际上几乎都是10%左右)每节课).

我试图增加模型的大小,以便尝试是否因为我的模型不够"强"到足以装配.但事实证明,无论我如何增加或减少模型大小,训练损失总是会在2.30附近停止下降.

我非常有信心我正确地实现了它,因为我的模型适用于更简单的任务,如MNIST(手写数字识别).所以我真的很想知道问题是什么.非常感谢.

conv1:卷积层与relu

pooling1:最大池层

fc1:带有relu的完全连接层

输出:带softmax的全连接层

码:

nn = NeuralNetwork(optimizer=Adam(0.001), log_dir='logs')
nn.add(Input('input', [32, 32, 3], ))
nn.add(Convolution2D(name='conv1', filter_height=3, filter_width=3, 
                     n_output_channels=256, activation_fn='relu'))
nn.add(Pooling2D('pooling1', mode='max', pool_shape=(3, 3), padding='SAME'))
nn.add(Convolution2D(name='conv2', filter_height=3, filter_width=3, 
                     n_output_channels=128, activation_fn='relu'))
nn.add(Pooling2D('pooling2', mode='max', pool_shape=(3, 3), padding='SAME'))
nn.add(FullyConnected('fc1', 384, activation_fn='relu',
                      weight_init=truncated_normal(), bias_init=constant(0.1)))
nn.add(FullyConnected('fc2', 192, activation_fn='relu', 
                      weight_init=truncated_normal(), bias_init=constant(0.1)))
nn.add(Output(loss_fn='sparse_softmax_cross_entropy', output_fn='softmax',
              name='output', target_shape=[], target_dtype=tf.int64, 
              output_shape=10))
nn.build()

编辑:

正如我所提到的.我试图通过添加更多图层来增加模型的复杂性,并且几乎尝试了教程中的那个,除了我没有标准层(conv1,pooling1,conv2,pooling2,fc1,fc2,softmax)和预处理像美白等.为简单起见,我认为这可能不会影响我的表现,从86%到10%严重.

我认为可能有帮助的另一条线索是我发现图层的输出fc1非常稀疏(几乎99%的元素都是零).由于我使用ReLU作为激活函数,这意味着fc1中的单位大部分都是死的.我有什么可以做的吗？

正如众所周知,在C#中,async应该方法后缀"异步"命名(例如ReadAsync,CreateAsync).

但在许多情况下,async/await在异步方法中没有必要,例如:

public async Task<string> DoSomethingAsync()
{
    return await GetAsync();
}

可以改写为:

public Task<string> DoSomethingAsync()
{
    return GetAsync();
}

我的问题是:

1. 对于上面的情况,哪里async/await是完全可选的,哪个版本更正确？保持async/await或Task直接返回？

2. 如果第二个版本更好(Task直接返回),它是否通常仍然以后缀"Async"(即DoSomethingAsync)或不是(即DoSomething)命名？

我是Typescript的新手,我试着在这个操场上玩TypeScript .我注意到在TypeScript中,基类中的受保护成员可以被公共成员覆盖:

class Base {
    protected name: string = '!'
}

class Derived extends Base{
    public name: string = '?'
}

一方面,这对我来说很有意义,因为Liskov替换原则仍然存在:基类比派生类有更严格的要求.但另一方面,我注意到私人成员不能被受保护或公开成员覆盖,这似乎与我不一致:

class Base {
    private name: string = '!'
}

class Derived extends Base{
    public name: string = '?'  // ERROR!
}

因此我想知道:

1. 我的观察是针对打字稿的预期行为还是错误？

2. 如果是这样的话,为什么存在这种不一致？为什么TypeScript要求所有覆盖成员具有与基类成员相同的可访问性？或者允许所有具有更高可访问性的派生成员覆盖基类中的成员？

我正在尝试创建在我的页面中搜索类的函数，ardiv然后在这些类中搜索具有名称的类，hiddenid但我仍然遇到错误

document.getElementsbyClassName 不是函数。

我已经阅读了许多具有相同错误的文章，但没有解决方案对我有帮助。

这是我的代码：

function hledat() {

var divs = document.getElementsbyClassName("ardiv");

for (var i = 0; i < divs.length; i++) {
    var para = divs[i].getElementsbyClassName( "hiddenid" ).value;
    alert( para );
}

}

hledat();