小编Bak*_*riu的帖子

我有一个树状的结构.此结构中的每个元素都应该能够返回它所属的所有元素的Enumerable.我们称之为这种方法IEnumerable<Foo> GetAll().所以,如果我们有

      A <-- topmost root
    /   \
   B     C
  / \   / \
  D  E  F  G

GetAll对元素C返回的调用{C, F, G}(元素的固定顺序很好,但不需要).我想每个人都已经知道了.

目前的实现GetAll看起来像这样:

public IEnumerable<Foo> GetAll ()
{
    yield return this;

    foreach (Foo foo in MyChildren) {
        foreach (Foo f in foo.GetAll ()) {
            yield return f;
        }
    }
}

在早期的实现中,我返回了一个List并添加了child-foos List.AddRange().

我的问题是,是否正确实施了使用产量的版本,或者是否应该改进(特别是在性能方面).或者这只是坏事我应该坚持Lists(或ReadOnlyCollections)而不是？

我是PySide的新手.我有一个主窗口对象,一次显示一个小部件.我一直在尝试更改类的中央窗口小部件,QMainWindow以便在按下按钮时替换窗口中的可见窗口小部件.问题是按下的按钮是在Widget类中,而不是在主窗口类中.

说...

class App(QtGui.QMainWindow):

    def __init__(self):
        super(App, self).__init__()

        self.initUI()

    def initUI(self):

        self.statusBar().showMessage('Listo.') #Status Bar
        self.login_screen = LoginScreen()
        self.logged_in_screen = LoggedInScreen()

        self.setCentralWidget(self.login_screen)

        self.setGeometry(300, 300, 450, 600) #Window Size
        self.setWindowTitle('PyTransactio - Client') #Window Title
        self.setWindowIcon(QtGui.QIcon('icon.png')) #App Icon
        self.show()

按下的按钮位于login_screen实例中.单击按钮时调用的方法位于LoginScreen类中:

def login(self):
        """ Send login data to the server in order to log in """

        #Process

        self.setParent(None)

设置父窗口小部件以从主窗口中None删除窗口小部件(login_screen).logged_in_screen当按下loginButton(在login_screen窗口小部件内)时,我应该怎么做才能将另一个窗口小部件(例如)作为主窗口的中央窗口小部件？

也许登录方法应该在主窗口类中？如果是这样,我如何连接按下的按钮login_screen与主窗口的方法？

有一次,在看了Mike Muller的性能优化教程(我认为这个)之后,一个想法开始存在于我的脑海中:如果性能很重要,最小化通过索引访问循环中的项目,例如,如果您需要x[1]在循环中多次访问for x in l-为变量赋值x[1]并在循环中重用它.

现在我有了这个合成的例子:

import timeit

SEQUENCE = zip(range(1000), range(1, 1001))

def no_unpacking():
    return [item[0] + item[1] for item in SEQUENCE]


def unpacking():    
    return [a + b for a, b in SEQUENCE]


print timeit.Timer('no_unpacking()', 'from __main__ import no_unpacking').timeit(10000)
print timeit.Timer('unpacking()', 'from __main__ import unpacking').timeit(10000)

unpacking()和no_unpacking()函数返回相同的结果.实现方式不同:unpacking()将项目解包到循环中a和b循环中; no_unpacking()通过索引获取值.

对于python27,它显示:

1.25280499458
0.946601867676

换言之,unpacking()表现优于no_unpacking()约25%.

问题是:

• 为什么通过索引访问会显着减慢事情(即使在这个简单的情况下)？

奖金问题:

• 我也试过这个pypy- …

因此在iOS Swift中,我们可以执行可选链接来简化nil检查,就像在官方文档中一样

let johnsAddress = Address()
johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street"
john.residence!.address = johnsAddress
if let johnsStreet = john.residence?.address?.street {
    println("John's street name is \(johnsStreet).")
} else {
    println("Unable to retrieve the address.")
}
// prints "John's street name is Laurel Street."

我了解在选购链接的使用john.residence?.address?.street,但我们怎样才能知道实际链条断裂(如果任一residence或者address是nil).我们可以判断residence或者address是nil,或者我们需要与检查一遍if-else？

foldr并且foldMap可以用于我理解的彼此定义.但这怎么可能,因为后者使用幺半群,而前者不是？我们是否有任何保证foldr作品上的东西可以有一个幺半群？

我正在尝试使用 ZDD 实现单变量多项式，如另一个问题的评论中所建议的。

我读过 S. Minato 的论文（你可以在这里下载）），但我不明白如何在这些ZDD上实现操作。

论文中的想法是多项式可以用x^(2^i)变量来表示。例如，x^5 + x^3 + x可以重写为x^4x^1 + x^2x^1 + x^1，如果您为每个x^(2^i)变量创建节点并与相乘的“1-边”变量和相加的“0-边”变量连接，您可以轻松获得表示该多项式的图形. ZDD 是这种图形，它在图形上强制执行某些条件（有关更多信息，请阅读 Minato 的文章和维基百科关于 BDD的页面）

可以使用 2 的幂之和类似地表示系数（例如，5 = 2^2 + 2^0每个2^i都是变量并且节点以相同的方式与 1 和 0 边连接）。

现在，我的问题是添加两个 ZDD 的算法。算法看起来很简单：

如果 F 和 G (ZDDs) 没有共同的组合，只需将它们合并即可完成加法 (F + G)。当它们包含一些常见的组合时，我们计算以下公式：(F + G) = S + (Cx2)，其中 C = F ? G, S = (FUG) \ C …

是否有可能,如果是的话,如何确定Cython中整数数据类型的大小(以位为单位)？

我正在尝试做这样的事情,以获得整数大小:

cdef WORD_BITS = 0
IF sizeof(unsigned long long) == 8:
    WORD_BITS = 64
    DEF VECTOR_LENGTH_SHIFT_AMOUNT = 6
ELSE:
    WORD_BITS = 32
    DEF VECTOR_LENGTH_SHIFT_AMOUNT = 5

ctypedef unsigned long long word_t

cdef int vector_length(size_t bit_size):

    cdef size_t size = bit_size >> VECTOR_LENGTH_SHIFT_AMOUNT
    if size << VECTOR_LENGTH_SHIFT_AMOUNT < bit_size:
        size += 1
    return size

cdef class BitVector(object):

    cdef size_t length
    cdef size_t array_size
    cdef word_t *array

    def __cinit__(self, size_t size):
        self.length = size
        self.array_size = vector_length(size)
        self.array = <word_t *>calloc(self.array_size, …

有没有一种简单的方法来在Python中模拟松散定义的dict对象？例如,如何在给定dict的情况下轻松表达input,我想检查其中的每个值是否符合特定的元定义,如最小值和最大值,长度和类型？

能够这样做可能很方便,例如,在编写测试时.

在mock(Python版本3.3+中的unittest.mock)中,可以指定值可以是ANY值,例如

>>> mock = Mock(return_value=None)
>>> mock('foo', bar=object())
>>> mock.assert_called_once_with('foo', bar=ANY)

但是,如果bar上面应该是类似dict的对象,就像

>>> {'baz': <an integer between -3 and 14>, 'qux': <'yes' or 'no'>}

我读从"learnyouahaskell"教程learnyouahaskell.它写着:

模式匹配也可以用在元组上.如果我们想要创建一个在2D空间中采用两个向量(以对形式)并将它们加在一起的函数,该怎么办？为了将两个向量相加,我们分别添加它们的x组件,然后分别添加它们的组件y.如果我们不了解模式匹配,我们将如何做到这一点:

addVectors :: (Num a) => (a, a) -> (a, a) -> (a, a)  
addVectors a b = (fst a + fst b, snd a + snd b)  

Run Code Online (Sandbox Code Playgroud)

嗯,这有效,但有一个更好的方法来做到这一点.让我们修改函数,使其使用模式匹配.

addVectors :: (Num a) => (a, a) -> (a, a) -> (a, a)  
addVectors (x1, y1) (x2, y2) = (x1 + x2, y1 + y2)  

Run Code Online (Sandbox Code Playgroud)

我们去!好多了.请注意,这已经是一个包罗万象的模式.addVectors(在两种情况下)的类型都是addVectors :: (Num a) => (a, a) -> (a, a) - > (a, a),所以我们保证得到两对作为参数.

我的问题是:如果两个定义产生相同的签名,为什么模式匹配首选首选方式？

我正在研究一种算法。但是作者提供的haskell代码我不是很清楚，所以我需要你们的帮助。我认为代码可以分为两部分。

> type LFT = (Integer, Integer, Integer, Integer)
>
> extr :: LFT -> Integer -> Rational
> extr (q,r,s,t) x = ((fromInteger q) * x + (fromInteger r)) / ((fromInteger s) * x + (fromInteger t))
>
> unit :: LFT
> unit = (1,0,0,1)
>
> comp :: LFT -> LFT -> LFT
> comp (q,r,s,t) (u,v,w,x) = (q*u+r*w,q*v+r*x,s*u+t*w,s*v+t*x)

这里，很明显，一个叫做LFT的类型（可能是Python中的元组）和三个叫做的函数extr unit comp被定义了。 然而，接下来的部分让我很困惑：

> pi = stream next safe prod cons init lfts …