相关疑难解决方法(0)

我一直致力于自动构建的基本测试框架.下面的代码段代表了使用不同程序的两台机器之间通信的简单测试.在我实际进行任何测试之前,我想完全定义它们 - 所以下面的测试实际上并没有在声明所有测试之后运行.这段代码只是一个测试声明.

remoteTests = []
for client in clients:
    t = Test(
        name = 'Test ' + str(host) + ' => ' + str(client),
        cmds = [
            host.start(CMD1),
            client.start(CMD2),

            host.wait(5),

            host.stop(CMD1),
            client.stop(CMD2),
        ],
        passIf = lambda : client.returncode(CMD2) == 0
    )
remoteTests.append(t)

无论如何,在运行测试之后,它运行'passIf'定义的函数.由于我想为多个客户端运行此测试,我正在迭代它们并为每个客户端定义测试 - 没什么大不了的.但是,在第一个客户端上运行测试之后,'passIf'会对客户列表中的最后一个进行评估,而不是lambda声明时的'client'.

我的问题是:python何时绑定lambdas中的变量引用？我想如果使用lambda外部的变量是不合法的,解释器就不知道我在说什么.相反,它默默地绑定到最后一个"客户端"的实例.

另外,有没有办法像我预期的那样强制解决问题？

我使用Python编写了一个简单的主筛(Eratosthenes的无界筛子),但由于某种原因,它无法正常工作.这是筛子:

from itertools import count

def sieve():
    nums = count(2)
    while True:
        n = next(nums)
        nums = filter(lambda k: k%n != 0, nums)
        yield n

不幸的是,这不起作用.相反,它只返回与count(2)迭代器相同的值.

为了比较,这个:

nums = count(2)
print(next(nums))
nums = filter(lambda k: k%2 != 0, nums)
print(next(nums))
nums = filter(lambda k: k%2 != 0, nums)
print(next(nums))

将打印:

2
3
5

而筛选功能将打印:

2 3 4

我认为问题在于Python的lambda的奇怪行为,但是替换了这一行:

nums = filter(lambda k: k%n != 0, nums)

有:

def f(k): return k%n != 0
nums = filter(f, nums)

没有解决问题.

我努力让lambdas工作.这里的代码是示例,但它很好地显示了我的问题.

lambdas = list()

for i in range(5):
    lambdas.append(lambda x:i*i*x)


print lambdas[0](1)
print lambdas[2](1)

这给了我16,但我希望不同的lambda有不同的价值.为什么会这样!

我有一个算法,可以生成一个主要列表作为生成器:

def _odd_iter():
    n=3
    while True:
        yield n
        n=n+2

def _not_divisible(n):
    return lambda x: x % n > 0

def primes():
    yield 2
    L=_odd_iter()
    while True:
        n=next(L)
        yield n
        L=filter(_not_divisible(n), L)

x=1
for t in primes():
    print(t)
    x=x+1
    if x==10:
        break

但是如果我将lambda filter函数直接放入函数中,如下所示:

def primes():
    yield 2
    L=_odd_iter()
    while True:
        n=next(L)
        yield n
        L=filter(lambda x: x%n>0, L)

我只能获得一个奇怪的列表,而不是一个主要列表.似乎filter功能不起作用.

我能做什么？

我为“ Eratosthenes筛”的试验部门变体提出了以下Python代码：

import itertools

def sieve():
    # begin with all natural numbers above 1
    picker = itertools.count(2)
    while True:
        # take the next available number
        v = next(picker)
        yield v
        # filter from the generator its multiples
        picker = filter(lambda x: x % v != 0, picker)

它没有按我预期的那样工作。

调试它时，我得到一些不知道何时filter被调用的行为：xlambda 的参数得到一个具体的参数，它是picker生成器中的下一个元素。即使查看的文档，我也无法理解这种行为filter。

跑步

s = sieve()
for i in range(5):
    print(next(s))

我得到：

2
3
4
5
6

代替

2
3 …

我在python中偶然发现了一个我很难理解的行为.这是概念验证代码:

from functools import partial

if __name__ == '__main__':
    sequence = ['foo', 'bar', 'spam']
    loop_one = lambda seq: [lambda: el for el in seq]
    no_op = lambda x: x
    loop_two = lambda seq: [partial(no_op, el) for el in seq]
    for func in (loop_one, loop_two):
        print [f() for f in func(sequence)]

以上的输出是:

['spam', 'spam', 'spam']
['foo', 'bar', 'spam']

行为loop_one对我来说是令人惊讶的,因为我希望它表现为loop_two:el是一个在每个循环中改变的不可变值(一个字符串),但lambda似乎存储一个指向"循环变量"的指针,就好像循环将循环序列中每个元素的相同内存地址.

上面的行为与包含for循环的完整函数相同(因此它不是列表理解语法).

但是等等:还有更多......更令人费解!

以下脚本的工作方式如下loop_one:

b = []
for foo in ("foo", "bar"): …

任何人都可以做健全性检查吗？

我正在尝试在 for 循环中创建函数。我无法理解的一点总结在以下代码中：

f_list = []
for i in range(10):
    f = lambda j : i
    f_list.append(f)

然后，

>>> f_list[0](0)
9                  #I hope this is 0.
>>> f_list[1](0)
9                  #I hope this is 1.

为什么会这样？？

我有一个关于在访问Spark RDD时在闭包中使用局部变量的问题.我想解决的问题如下:

我有一个应该读入RDD的文本文件列表.但是,首先我需要向从单个文本文件创建的RDD添加其他信息.从文件名中提取此附加信息.然后,使用union()将RDD放入一个大的RDD中.

from pyspark import SparkConf, SparkContext
spark_conf = SparkConf().setAppName("SparkTest")
spark_context = SparkContext(conf=spark_conf)

list_of_filenames = ['file_from_Ernie.txt', 'file_from_Bert.txt']
rdd_list = []
for filename in list_of_filenames:
    tmp_rdd = spark_context.textFile(filename)
    # extract_file_info('file_from_Owner.txt') == 'Owner'
    file_owner = extract_file_info(filename)   
    tmp_rdd = tmp_rdd.map(lambda x : (x, file_owner))
    rdd_list.append(tmp_rdd)
overall_content_rdd = spark_context.union(rdd_list)
# ...do something...
overall_content_rdd.collect()
# However, this does not work: 
# The result is that always Bert will be the owner, i.e., never Ernie.

问题是循环中的map()函数没有引用"正确的"file_owner.相反,它将引用file_owner的最新值.在我的本地机器上,我设法通过为每个RDD调用cache()函数来解决问题:

# ..
tmp_rdd = tmp_rdd.map(lambda x : (x, file_owner)) …

我想在一个循环中制作5个按钮,并为每个按钮绑定一个推荐来打印索引.在以下解决方案中,它始终打印相同的索引.

我的代码是这样的:

for i in range(5):
    make_button = Tkinter.Button(frame, text ="make!", 
                                 command= lambda: makeId(i))

def makeId(i):
    print(i)

它总是打印5.我该如何解决这个问题？

根据我的编程语言课程，在使用词法范围的语言中

val x = 1
fun myfun () =
    x
val x = 10
val res = myfun()  (* res is 1 since x = 1 when myfun is defined *)

x = 1
def myfun():
    return x
x = 10
myfun()  # 10 since x = 10 when myfun is called