Tim Peters

对不起,我不明白你想做什么。例如,这一行:

   assert not all(thread.join() for thread in threads)

这根本没道理。 .join() 总是 返回 None ,所以和

   assert not all(None for thread in threads)

除了它有连接螺纹的副作用。 all() 第一次看到故障时短路 False 价值,哪个 没有一个 是的,所以只有第一个 .加入 实际上叫。 all(...) 返回 错误的 所以 not all(...) 返回 True ,所以 assert 成功了。就像:

    threads[0].join()
    assert True

短期课程: 任何 代码是否关注值 thread.join() 回报很可能是断断续续的,因为 没有一个 是它唯一能看到的价值。

这是一个非常干净的方法。你会很高兴弄清楚它是如何工作的:-)

def expander(s):
    import re
    from itertools import product
    pat = r"\(([^)]*)\)"
    pieces = re.split(pat, s)
    pieces = [piece.split("|") for piece in pieces]
    for p in product(*pieces):
        yield "".join(p)

然后:

for s in ('(A|B|C)_STRING',
          '(|A_)STRING',
          'STRING_(A|B)_STRING_(C|D)'):
    print s, "->"
    for t in expander(s):
        print "   ", t

显示:

(A|B|C)_STRING ->
    A_STRING
    B_STRING
    C_STRING
(|A_)STRING ->
    STRING
    A_STRING
STRING_(A|B)_STRING_(C|D) ->
    STRING_A_STRING_C
    STRING_A_STRING_D
    STRING_B_STRING_C
    STRING_B_STRING_D

你确定吗? product() 迭代传递给它的iterables,但只有一级深度。

>>> from itertools import product
>>> mylist = [[1, 2], ['a', 'b'], [[4, 6], [8, 9]]]
>>> for x in product(*mylist):
...     print(x)
(1, 'a', [4, 6])
(1, 'a', [8, 9])
(1, 'b', [4, 6])
(1, 'b', [8, 9])
(2, 'a', [4, 6])
(2, 'a', [8, 9])
(2, 'b', [4, 6])
(2, 'b', [8, 9])

看见那个 [4, 6] 和 [8, 9] 它们本身就是不相关的 产品() .

你的Python代码不是唯一运行的东西。Python标准库的大部分内容都是编写的 在里面 Python,这取决于您使用的shell,这可能会导致在第一次键入之前导入相当多的模块。在CPython 3.10.0的空闲状态下:

>>> import sys
>>> len(sys.modules)
159

因此,只要到达提示(!)模块“在封面下”。

“小”整数对象由CPython实现跨用途共享。所有这些模块中的每个3实例都会增加3的refcount。以下是其他一些:

>>> for i in range(-10, 11):
...     print(i, sys.getrefcount(i))
-10 3
-9 3
-8 3
-7 3
-6 3
-5 9
-4 5
-3 12
-2 25
-1 190
0 914
1 804
2 363
3 144
4 202
5 83
6 83
7 38
8 128
9 54
10 64

所以3“相当受欢迎”,但0是容易的赢家。但是没有其他东西在使用,例如-10或-9。

但请注意 知道 这对你来说没有实际价值。Python是否以及何时共享不可变对象由实现定义,并且可以(而且确实如此!)在不同版本之间进行更改。

如果你想的话,你必须自己重新格式化 \x 到处逃走;例如。,

>>> import struct
>>> r = struct.pack('2I',12, 33)
>>> r
b'\x0c\x00\x00\x00!\x00\x00\x00'
>>> list(r)
[12, 0, 0, 0, 33, 0, 0, 0]
>>> print("".join("\\x%02x" % i for i in r))
\x0c\x00\x00\x00\x21\x00\x00\x00

建筑物 O(N**2) 序列化代码中未使用的3元素dict,并通过进程间管道传输它们,是保证多处理无法帮助的非常好的方法;-)没有免费的东西-一切都要花钱。

下面是一个执行很多 相同的 不管它是在串行还是多处理模式下运行的代码。一般来说,没有新的口述等 len(coords) ,它从多处理中获得的好处越多。在我的盒子里,20000次的多处理运行需要大约三分之一的挂钟时间。

关键是所有进程都有自己的 coords . 这是通过在创建池时只传输一次来完成的。这应该在所有平台上都有效。在Linux-Y系统上,它可以通过“魔术”而不是分叉进程继承来实现。减少跨进程发送的数据量 o(n×2) 到 O(N) 是一个巨大的进步。

从多处理中获得更多信息需要更好的负载平衡。按原样,打电话给 check_overlap(i) 比较 coords[i] 中的每个值 coords[i+1:] . 较大的 i ,它要做的工作越少,最大值为 我 只是传输的成本 我 在进程之间-并将结果传输回-占用了大量的时间 在里面 检查重叠(I) .

def init(*args):
    global _coords, _tolerance
    _coords, _tolerance = args

def check_overlap(start_index):
    coords, tolerance = _coords, _tolerance
    tsq = tolerance ** 2
    overlaps = 0
    start0, start1 = coords[start_index]
    for i in range(start_index + 1, len(coords)):
        that0, that1 = coords[i]
        dx = abs(that0 - start0)
        if dx <= tolerance:
            dy = abs(that1 - start1)
            if dy <= tolerance:
                if dx**2 + dy**2 <= tsq:
                    overlaps += 1
    return overlaps

def process_coords(coords, num_processors=1, tolerance=1):
    global _coords, _tolerance
    import multiprocessing as mp
    _coords, _tolerance = coords, tolerance
    import time

    if num_processors > 1:
        pool = mp.Pool(num_processors, initializer=init, initargs=(coords, tolerance))
        start = time.time()
        print("Start script w/ multiprocessing")
    else:
        num_processors = 0
        start = time.time()
        print("Start script w/ standard processing")

    N = len(coords)
    if num_processors:
        total_overlap_count = sum(pool.imap_unordered(check_overlap, range(N))) 
    else:
        total_overlap_count = sum(check_overlap(i) for i in range(N))

    print(total_overlap_count)
    print("  time: {0}".format(time.time() - start))

if __name__ == "__main__":
    from random import random

    coords = []
    num_coords = 20000
    spread = 100.0
    half_spread = 0.5*spread
    for i in range(num_coords):
        coords.append([
            random()*spread-half_spread,
            random()*spread-half_spread
        ])

    process_coords(coords, 1)
    process_coords(coords, 4)

这就是 quantize() 方法用于:

>>> mydecimal.quantize(resolution)
Decimal('1.4523')

读文件,或者做

>>> help(mydecimal.quantize)

更多信息。注意:您的 resolution 变量不重要-它是内部指数 量化()

>>> resolution = Decimal('0.0009')

相反。

在程序的一次运行中,并提供了一个dict d 在两者之间没有变异,那么

d.items()
d.iteritems()
d.keys()
d.iterkeys()
d.values()
d.itervalues()

它们都是一致的,并且每次都返回相同的序列。

但是,如果修改dict,它可能会在内部收缩或增长并重新排列,这会改变顺序。在下一个突变之前,它们将保持不变。

编辑:有一个例外,这是经过深思熟虑的。如果仅替换与现有键关联的值,则顺序将 不 改变。所以如果 k in d 是 True , d[k] = v 是无害的。但是,如果添加新密钥或删除密钥,则所有赌注都将取消。

对于一个 OrderedDict 它固有地 O(n) 因为排序记录在 linked list .

对于内置dict,有一个向量(一个连续数组)而不是一个链表,但最后基本上是一样的:向量包含一些“假人”,特殊的内部值意味着“还没有在这里存储密钥”或“以前在这里存储但现在不再存储的密钥”。这使得,例如,删除一个键非常便宜(只需用一个虚拟值覆盖该键)。

但是,如果不在上面添加辅助数据结构,就没有办法跳过这些假人,而不逐个跳过它们。因为python使用开放寻址的形式来解决冲突,并且将负载系数保持在2/3以下,至少是向量项的三分之一。 是 傻瓜。 the_vector[i] 可以在中访问 O(1) 时间,但与第i个非虚拟条目没有可预测的关系。