今天我探讨了Python 的奇怪行为.一个例子:
closures = []
for x in [1, 2, 3]:
# store `x' in a "new" local variable
var = x
# store a closure which returns the value of `var'
closures.append(lambda: var)
for c in closures:
print(c())
上面的代码打印出来
3
3
3
但是我希望它能打印出来
1
2
3
我为自己解释了这种行为,var它始终是相同的局部变量(并且python不像其他语言那样创建新的行为).如何修复上面的代码,以便每个闭包都返回另一个值？
我有这个python代码,它将几个lambda函数放在一个字典中:
dictfun = dict()
for txt in ("a", "b", "c"):
dictfun[txt] = lambda: "function " + txt
这些函数只返回一个字符串,其中包含调用它们的参数.
我希望看到像function afor dictfun["a"](),function bfor dictfun["b"]()等的输出,但这就是我得到的:
>>> dictfun["a"]()
'function c'
>>> dictfun["b"]()
'function c'
>>> dictfun["c"]()
'function c'
它们似乎都评估txt到它设置的最后一个值,即它的当前值.总之,变量不会关闭到lambdas中.我甚至可以这样做:
>>> txt = "a"
>>> dictfun["c"]()
'function a'
我如何才能关闭txtlambda函数以获得预期的输出？
说我有一个功能
def my_meta_function (a, b, c):
pass
我想定义一个函数数组myfunctions = [f1, f2, f3, ... f100],其中参数c固定为每个这样的函数的不同值,例如c = [1,2,3, .. 100],函数只接受参数a和b.在实践中,我正在考虑的论点更复杂,但我试图理解如何在语言中这样做.
我的 python 代码中有一个循环，它为我的大叶地图添加了功能。每个功能都保存在一个字典中（称为产品），每个功能都有一个参数字典（GeoJson 字符串和属性）。我想根据其中一个参数为特征着色。
我首先为参数创建一个唯一值列表。然后我将颜色映射到每个唯一值：
orb_list = [value['relativeorbitnumber'] for key, value in products.items()]
orb_list = list(set(orb_list))
color_cycle = cycler(color=['#8e0038', '#8e0073', '#59008e'], fillColor=['#8e0038', '#8e0073', '#59008e'])
orb_colors=dict([[i, sty] for i, sty in zip(orb_list, cycle(color_cycle))])
接下来，我创建一个循环，在该循环中检索与特征参数值对应的颜色和填充颜色，并在 style_function 中使用它：
for key,value in products.items():
footprint = json.dumps(wkt.loads(products[key]['footprint']))
fillColor = orb_colors[products[key]['relativeorbitnumber']]['fillColor']
color = orb_colors[products[key]['relativeorbitnumber']]['color']
feat = folium.GeoJson(footprint,
style_function=lambda x: {'fillColor':fillColor,'color':color},
highlight_function=lambda feature: {'fillcolor':'green','color':'green'},
name='Footprint')
feat.add_to(mapa)
我认为这会起作用，但是所有功能似乎都由我循环中的最后一个“fillColor”和“color”着色。谁能解释这是为什么？我假设在所有循环完成之前不会渲染这些特征，因此“color”和“fillColor”的最后一个值用于所有特征。你能建议我应该如何修改我的代码来解决这个问题吗？或者，也许我以错误的方式处理它，您可以建议一种更清洁的方法？
我正在尝试制作一个程序来创建格式的 lambda 函数列表y=mx+b，其中“m”和“b”是预先确定的值
我的总体目标是实现一个功能，那
基本上，如果你知道那是什么，像霍夫变换的东西。
一旦我有了特定图像的线条，我就可以创建一个 lambda 函数来表示线条的斜率及其起点。我遇到了无法将 lambda 函数附加到列表的问题。
我试过这个：
if __name__ == "__main__":
nums = []
for i in range(10):
j = lambda x: x + i
nums.append(j)
for i in nums:
print(i(1))
这是我得到的错误：
Traceback (most recent call last):
File "C:/Users/me/.PyCharmCE2018.3/config/scratches/scratch_3.py", line 7, in <module>
print(i(1))
File "C:/Users/me/.PyCharmCE2018.3/config/scratches/scratch_3.py", line 4, in <lambda>
j = (lambda x: x + i)
TypeError: unsupported operand type(s) for +: 'int' and 'function'
我有一系列函数,例如:
>>> def f():
... print "f"
...
>>> def g():
... print "g"
...
>>> c=[f,g]
然后我尝试创建两个lambda函数:
>>> i=0
>>> x=lambda: c[i]()
>>> i+=1
>>> y=lambda: c[i]()
然后,打电话给他们:
>>> x()
g
>>> y()
g
为什么lambda中的c [i]是一样的？
我不理解一段代码的行为,涉及一个在不同对象中调用方法的lambda函数的理解列表.它发生在一个大型程序中,所以对于这个问题,我做了一个荒谬的玩具案例来表明我的观点:
class Evaluator(object):
def __init__(self, lft, rgt):
self.lft = lft
self.rgt = rgt
def eval(self, x):
return self.lft + x * (self.rgt - self.lft)
if __name__ == "__main__":
ev1 = Evaluator(2, 3)
ev2 = Evaluator(4, 5)
ev3 = Evaluator(6, 7)
funcs = [lambda x:ev.eval(x+0.1) for ev in (ev1, ev2, ev3)]
print([f(0.5) for f in funcs])
我得到的输出是[6.6, 6.6, 6.6],这意味着它是ev3一直被评估的方法.而不是[2.6, 4.6, 6.6]像我期望的那样.但令我惊讶的是,如果我摆脱lambda函数,行为就好了:
class Evaluator(object):
def __init__(self, lft, rgt):
self.lft = lft
self.rgt = rgt
def eval(self, …以下是我似乎没有得到的代码片段。问题是如何让函数输出想要的结果（不说想要的结果是什么，我假设它打印的是 0 到 9）。
这是一个问题： 下面的代码片段打印出什么？我们如何修复匿名函数以达到我们期望的行为？
functions = []
for i in range(10):
functions.append(lambda : i)
for f in functions:
print(f())
我遇到的部分代码如下，其中workers是类对象的列表：
worker_threads = []
for worker in workers:
worker_fn = lambda worker=worker: worker.run(sess, coord, FLAGS.t_max)
t = threading.Thread(target=worker_fn)
t.start()
worker_threads.append(t)
通常我期望lambdais的语法lambda x : func(x)，但在这里worker=worker用于什么？
我想在我的类中定义许多方法TestClass。我想呼唤他们的名字TestClass().method_1......TestClass().method_n
我不想间接调用它们，例如通过中间方法来TestClass().use_method('method_1', params)保持与代码其他部分的一致性。
我想动态定义我的众多方法，但我不明白为什么这个最小的示例不起作用：
class TestClass:
def __init__(self):
method_names = [
'method_1',
'method_2']
for method_name in method_names:
def _f():
print(method_name)
# set the method as attribute
# (that is OK for me that it will not be
# a bound method)
setattr(
self,
method_name,
_f)
del _f
if __name__ == '__main__':
T = TestClass()
T.method_1()
T.method_2()
print(T.method_1)
print(T.method_2)
输出是：
function_2
function_2
<function TestClass.__init__.<locals>._f at 0x0000022ED8F46430>
<function TestClass.__init__.<locals>._f at 0x0000022EDADCE4C0>
当我期待的时候
function_1
function_2
我尝试在很多地方放置一些 …
我只是想知道如何在C++中编写一个Lambda函数,它"记住"下次调用它时传入的值？具体来说,我正在考虑i=iPython 的语法如下:
funs = [(lambda i=i: i) for i in range(10)]
如果运行以下代码:
for i in range(len(funs)):
print funs[i]()
结果是:
0
1
4
9
16
我也想知道技术名称(如果存在的话)是什么？(我知道,如果我知道第二个问题的答案,我可以通过Google获得解决方案......)
我正在学习Python中的lambdas.我需要创建一个函数列表,f = [f1, f2...]以便每个函数都fi(x)接受一个列表x并返回(x[i]-1).
这就是我尝试编码的方式,但我得到了令人惊讶的结果.请帮助我理解为什么三个打印件中的每一个都给出不同的结果.最后两个让我绝对难过!
f = [(lambda x: x[i]-1) for i in range(5)]
# I expect f to be [ (lambda x: x[0]-1), (lambda x: x[1]-1), ...]
x = [1, 2, 3, 4, 5]
print f[0](x), f[1](x), f[2](x) # output: 4 4 4 !!
print [f[i](x) for i in range(5)] # output: [0, 1, 2, 3, 4] as expected
print [f[k](x) for k in range(5)] # output: [4, 4, 4, 4, …