小编Let*_*t4U的帖子

一个特殊的问题，给定一个列表列表（这里最多嵌套一层）：

[['a', 'b'], 'c', ['d', 'e'], ['f', 'g'], 'h']

..找到所有长度与给定列表相同的列表，并包含来自子列表的元素的所有可能组合，给定子列表的 1 个元素与原始子列表位于相同的位置（甚至很难用文字表达）。也就是说，找到这个：

['a', 'c', 'd', 'f', 'h']
['a', 'c', 'd', 'g', 'h']
['a', 'c', 'e', 'f', 'h']
['a', 'c', 'e', 'g', 'h']
['b', 'c', 'd', 'f', 'h']
['b', 'c', 'd', 'g', 'h']
['b', 'c', 'e', 'f', 'h']
['b', 'c', 'e', 'g', 'h']

现在，我找到了解决方案，但对我来说并不令人满意：

def all_paths(s, acc=None, result=None):
    # not using usual "acc = acc or []" trick, because on the next recursive call "[] or []" would be
    # evaluated …

这样安全吗？

class SpecialAlert(Exception):

    def __init__(self, message, **kwargs):
        Exception.__init__(self, message)
        for kw in kwargs:
            if kw == 'message':
                continue
            setattr(self, kw, kwargs[kw])

有关：在现代Python中声明自定义异常的正确方法？

屁股..这安全吗？我的意思是我要超越自我的属性？

在SpecialAlert中，我想传递所有类型的内容（这是一连串的不同检查的例外，我在循环中执行“ try..except SpecialAlert as error”，然后从处理程序中的错误中获取详细信息）

如果没有覆盖“消息”，我有一个基本的检查，是否也应该跳过对自己设置其他属性？这些是什么？

我需要将大量的UNIX时间戳舍入到它们各自的分钟(再次表示为时间戳).

出于纯粹的好奇心,我计时两种方法:

%timeit (127/60)*60
10000000 loops, best of 3: 76.2 ns per loop

%timeit 127 - 127%60
10000000 loops, best of 3: 34.1 ns per loop

我跑了好几次,第二种方法的速度一直是第一种方法的两倍.为什么差异如此之大？

这是那些“出于纯粹的好奇心而提出的（可能徒劳的希望我会学到一些东西）”的问题。

我正在研究在大量字符串上节省内存的方法，在某些情况下，在numpy中执行字符串操作似乎很有用。但是，我得到了一些令人惊讶的结果：

import random
import string

milstr = [''.join(random.choices(string.ascii_letters, k=10)) for _ in range(1000000)]

npmstr = np.array(milstr, dtype=np.dtype(np.unicode_, 1000000))

使用的内存消耗memory_profiler：

%memit [x.upper() for x in milstr]
peak memory: 420.96 MiB, increment: 61.02 MiB

%memit np.core.defchararray.upper(npmstr)
peak memory: 391.48 MiB, increment: 31.52 MiB

到目前为止，一切都很好; 但是，计时结果令我惊讶：

%timeit [x.upper() for x in milstr]
129 ms ± 926 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit np.core.defchararray.upper(npmstr)
373 ms ± 2.36 ms …

这是我从其他地方获得的结构,即深度嵌套字典的列表:

{
    "foo_code": 404,
    "foo_rbody": {
        "query": {
            "info": {
                "acme_no": "444444",
                "road_runner": "123"
            },
            "error": "no_lunch",
            "message": "runner problem."
        }
    },
    "acme_no": "444444",
    "road_runner": "123",
    "xyzzy_code": 200,
    "xyzzy_rbody": {
        "api": {
            "items": [
                {
                    "desc": "OK",
                    "id": 198,
                    "acme_no": "789",
                    "road_runner": "123",
                    "params": {
                        "bicycle": "2wheel",
                        "willie": "hungry",
                        "height": "1",
                        "coyote_id": "1511111"
                    },
                    "activity": "TRAP",
                    "state": "active",
                    "status": 200,
                    "type": "chase"
                }
            ]
        }
    }
}

{
    "foo_code": 200,
    "foo_rbody": {
        "query": {
            "result": {
                "acme_no": "260060730303258",
                "road_runner": "123", …

基本上我对Go 1.2有同样的问题,如下所述:

https://groups.google.com/forum/#!topic/golang-nuts/TYai0DVoYwg

有没有办法增加我的Go程序的StackMin而不重新编译Go？

假设我有一个像这样的简单字典：

d = {'k1':'v1', 'key2':'val2'}

如何key, value使用该词典在pystache中渲染线条？

我已经安装（我认为）带有 CUDA 支持的 TF 使用 command pip3.6 install tensorflow-gpu，每个 TF 安装页面。

我的本地 CUDA 安装是 CUDA 9.0 和 CUDNN 7.3.1 in /usr/local/cuda-9.0.

每个提示https://github.com/tensorflow/tensorflow/issues/10827我正在检查 TF 使用的库（在 virtualenv 中）：

% python -c 'import tensorflow as tf; print(tf.sysconfig.get_lib() + "/python/_pywrap_tensorflow_internal.so")' | xargs ldd
linux-vdso.so.1 (0x00007fff57eb8000)
libtensorflow_framework.so => /home/mark/projects/bench/venvs/ve_tf/lib/python3.6/site-packages/tensorflow/python/../libtensorflow_framework.so (0x00007ff29fa25000)
libcublas.so.9.0 => /usr/local/cuda-9.0/lib64/libcublas.so.9.0 (0x00007ff29bda8000)
libcusolver.so.9.0 => /usr/local/cuda-9.0/lib64/libcusolver.so.9.0 (0x00007ff2971ad000)
libcudart.so.9.0 => /usr/local/cuda-9.0/lib64/libcudart.so.9.0 (0x00007ff296f40000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007ff296d3c000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007ff296b1f000)
libgomp.so.1 => /usr/lib/x86_64-linux-gnu/libgomp.so.1 (0x00007ff2968f2000)
libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007ff2965ee000)
librt.so.1 => /lib/x86_64-linux-gnu/librt.so.1 …

最初的问题:对于给定的3x3 tic tac toe board,检查其中一个玩家是否赢了.

到目前为止,我提出的最简单的解决方案是旋转矩阵并总结每一行:

board
[[0, 1, 2], [3, 4, 5], [6, 7, 8]]

pr(board)
0 1 2
3 4 5
6 7 8

pr(zip(*board))
0 3 6
1 4 7
2 5 8

0..9以上数字仅用于显示棋盘上的位置,通常他们将为球员1填充1,为球员2填充-1,为未填充位置填充0.逐行进行,如果总和达到3或-3,则这是获胜区块.

但是,不检查对角线.有没有办法以优雅+高效的方式从这样的矩阵中提取对角线？我并不是指"手动"(0,1,2)使用普通索引,而是获得nxn矩阵的对角线.

PS pr只是打印2d列表的辅助函数:

def pr(x):
    for row in x:
        print ' '.join(map(str, row))

开始学习Haskell:

*Main> map double [1,2,3]
[2,4,6]

*Main> sum (map double [1,2,3])
12

*Main> (sum . map) (double) ([1,2,3])

<interactive>:71:8:
Couldn't match type ‘[b0] -> [b0]’ with ‘[[t0] -> t]’
Expected type: (b0 -> b0) -> [[t0] -> t]
  Actual type: (b0 -> b0) -> [b0] -> [b0]
Relevant bindings include it :: t (bound at <interactive>:71:1)
Probable cause: ‘map’ is applied to too few arguments
In the second argument of ‘(.)’, namely ‘map’
In the expression: sum . map

根据这个答案: …

我试图ThreadPoolExecutor在Windows 7上的Python 3.6中使用，似乎异常被忽略或停止了程序执行。示例代码：

#!/usr/bin/env python3

from time import sleep

from concurrent.futures import ThreadPoolExecutor

EXECUTOR = ThreadPoolExecutor(2)


def run_jobs():
    EXECUTOR.submit(some_long_task1)
    EXECUTOR.submit(some_long_task2, 'hello', 123)
    return 'Two jobs was launched in background!'


def some_long_task1():
    print("Task #1 started!")
    for i in range(10000000):
        j = i + 1
    1/0
    print("Task #1 is done!")


def some_long_task2(arg1, arg2):
    print("Task #2 started with args: %s %s!" % (arg1, arg2))
    for i in range(10000000):
        j = i + 1
    print("Task #2 is done!")


if __name__ == '__main__': …

我不太喜欢这样：Accessing python dict with multiple key lookup string

所以：

In [113]: d = {'a':1, 'b':2}

In [114]: va, vb = map(d.get, ['a', 'b'])

In [115]: va, vb
Out[115]: (1, 2)

但：

In [116]: va, vb = map(d.get, ['a', 'X'])

In [117]: va, vb
Out[117]: (1, None)

如果需要一个不同于 None 的默认值怎么办？

我可以使用 lambda：

In [118]: va, vb = map(lambda x: d.get(x) or 'MyDefault', ['a', 'c'])

In [119]: va, vb
Out[119]: (1, 'MyDefault')

但是，对于编写 2 个 d.get(key, 'MyDefault') 调用来说，这是一种令人费解的并且不是很经济的权衡。

有什么更好的（缺少为此编写简单实用函数的明显解决方案）？特别是 在 Python …