// Select is necessary so bucket contents are streamed too
yield return resultSelector(bucket.Select(x => x));

有一条我不太明白的评论.我已经测试了这种方法而没有使用Select,它运行良好.但似乎有一些我遗漏的东西.我想不出任何必要的例子,那么在这里使用Select(x => x)的实际目的是什么？

以下是完整的源代码供参考：

private static IEnumerable<TResult> BatchImpl<TSource,TResult>(
        this IEnumerable<TSource> source,int size,Func<IEnumerable<TSource>,TResult> resultSelector)
    {
        TSource[] bucket = null;
        var count = 0;

        foreach (var item in source)
        {
            if (bucket == null)
                bucket = new TSource[size];

            bucket[count++] = item;

            // The bucket is fully buffered before it's yielded
            if (count != size)
                continue;

            // Select is necessary so bucket contents are streamed too
            yield return resultSelector(bucket.Select(x => x));

            bucket = null;
            count = 0;
        }

        // Return the last bucket with all remaining elements
        if (bucket != null && count > 0)
            yield return resultSelector(bucket.Take(count));
    }

迭代器块行为也没有问题 – 每次我们回到这个实现时,都会重置并重新创建存储桶(在yield之后,bucket = null).即使有人将结果转换为数组类型并修改它,我们也不在乎.

这种方法的一个优点似乎只是优雅：在对resultSelector的所有调用之间存在类型一致性.没有“冗余”选择,实际类型大部分时间都是TSource [],IEnumerable< TSource>对于没有填满整个桶的尾随元素.

但是,可以想象以下场景：

>使用此函数的人注意到实际类型是数组
>由于需要提高性能,他们将收到的批量转换为TSource [](例如,他们现在可以更有效地跳过元素,as Skip is not optimized for arrays)
>他们使用该方法没有任何问题,因为在他们的情况下发生Count()％size == 0

直到,之后,会发生一个额外的元素弹出,导致最后一个产量被执行.现在,对TSource []的强制转换将会失败.

因此,根据元素的数量和大小,方法在结果类型方面的行为会不一致(传递给给定的回调).可以想象其他复杂的情况,这种不一致可能会导致麻烦,例如某些ORM,根据实际类型,将对象序列化到不同的表中.在这种情况下,数据片段最终会出现在不同的表格中.

这些场景当然都是基于其他一些错误,并没有证明没有Select实现是错误的.然而,从某种意义上说,它对Select更加友好,它将这种不幸情景的数量减少到最少.

这个类有一个__del__方法用于常规清理.如果我在正常执行脚本期间删除了类,我想要完成一些清理工作.

我也有一个信号处理程序,它做了一些不寻常的清理工作.如果脚本在收到信号时正在执行其他操作,则需要进行一些额外的清理,然后进行常规清理.

我注意到做del self和self .__ del __()之间有区别.

也就是说,self .__ del __()调用del方法两次.

你能解释一下为什么会这样吗？

这是一个模拟脚本来说明问题：

import sys
import signal
from optparse import OptionParser


class TestClass(object):
    def __init__(self,del_self):
        self.del_self = del_self

        print "__init__ with del_self = %s" % self.del_self

    def __del__(self):
        print "Now performing usual cleanup."

    def signal_handler(self,arg_1,arg_2):
        print "Received signal. Now performing unusual cleanup."

        # Unusual cleanup

        print "Did unusual cleanup"

        if self.del_self:
            print("Doing del self")
            del self
        else:
            print("Doing self.__del__()")
            self.__del__()

        sys.exit(0)


if __name__ == '__main__':
    arguments = sys.argv[1:]
    parse = OptionParser("Test.")
    parse.add_option(
        "-d","--delself",help="Set del self.",type="int",default=1
    )

    (options,_) = parse.parse_args()

    print "Options: %s" % options

    tc = TestClass(del_self=options.delself)

    signal.signal(signal.SIGQUIT,tc.signal_handler)

    while True:
        pass

如果我运行脚本：

python deltest.py --delself 1

并发出killall -3 python我得到：

Received signal. Now performing unusual cleanup.
Did unusual cleanup
Doing del self
Now performing usual cleanup.

在哪里,如果我再次执行python deltest.py –delself 0后跟kill信号,我得到：

Received signal. Now performing unusual cleanup.
Did unusual cleanup
Doing self.__del__()
Now performing usual cleanup.
Now performing usual cleanup.

为什么__del__方法在这种情况下执行了两次？

谢谢！

除了运行该方法外,手动调用__del__也没有任何作用;它不会删除任何东西.

什么工作是删除对象的最后一个引用：在这种情况下,主方法内的del tc将删除最后一个引用,据我所知.然后该对象将被垃圾收集,然后Python调用__del__.

这就是__del__发生两次的原因：一次是手动将其称为普通函数,一次是在程序结束时对象进行垃圾回收.

import numpy as np
a = np.array([1,2,3,4,5,6])
print(np.where(a > 2))

获得一个指数数组是很自然的,其中一个> 2,即[2,5],但我们得到：

(array([2,dtype=int64),)

即一个空的第二个成员的元组.

然后,为了获得numpy.where的“自然”答案,我们必须这样做：

np.where(a > 2)[0]

这个元组有什么意义？它在哪种情况下有用？

注意：我在这里只是谈论用例numpy.where(cond)而不是numpy.where(cond,x,y)也存在(参见文档).

在2个维度中考虑此示例：

a = np.array([[1,6],[-2,1,5]])

print(np.where(a > 2))

(array([0,1],array([2,dtype=int64))

如您所见,元组的第一个元素是指相关元素的第一维;第二个元素指的是第二个维度.

这是一个经常使用的常规numpy.当你要求数组的形状时,你也会看到它,即一维数组的形状将返回一个带有1个元素的元组：

a = np.array([[1,5]])

print(a.shape,a.ndim)  # (2,6) 2

b = np.array([1,6])

print(b.shape,b.ndim)  # (6,) 1