小编Jim*_*ard的帖子

我有两个清单:

list_1 = [0, 1, 0, 0, 0, 0, 1]
list_2 = [34, 54, 23, 54, 656 34, 100]

我想只将list_2索引所在list_2的值与实际相同索引的值1 相加list_1.

这里的例子是 54 + 100 = 154

我怎么能用Pythonic方式在Python中做到这一点？

我想做这样的事情:

def myFunc(y):
    aVariable = "a"
    bVariable = "b"
    y(aVariable,bVariable)

def main():
    myFunc(lambda a,b: a+=b)

并期望输出"ab".

相反,我收到以下错误:

File "<stdin>", line 7
  myFunc(lambda x, y: x += y)
                        ^
SyntaxError: invalid syntax

在我的节目，我有25个不同的功能命名"task1"，"task2"，"task3"，等...此刻我可以从一个单独的文件中对这些函数调用，并做他们的外壳：

import examplefilename
tasknum = str(input("Which task would you like to see? "))
task = "task" + tasknum
methodToCall = getattr(examplefilename, task)
result = methodToCall()

尽管我所做的只能从另一个文件中调用，所以如何从同一文件中以这种方式执行功能呢？

我正在将用Python 2编写的源代码转换为Python 3,我偶然发现:

from Queue import Queue, Empty

我改成了:

from multiprocessing import Queue, Empty

但这给了我一个例外:

ImportError: cannot import name 'Empty'

我该如何解决？

我有一个函数有两个递归调用,我试图将其转换为迭代函数.我已经弄明白我可以通过一个电话很容易地做到这一点,但我无法弄清楚如何合并另一个电话.

功能:

def specialMultiplication(n):
    if n < 2:
        return 1
    return n * specialMultiplication(n-1) * specialMultiplication(n-2)

如果我只有其中一个,那将非常容易:

def specialMult(n, mult = 1):
    while n > 1: 
        (n, mult) = (n-1, n * mult) # Or n-2 for the second one
    return mult

我只是无法弄清楚如何添加第二个调用以获得正确的答案.谢谢!

如果我有一个需要n从列表中返回随机元素的函数,我可能想检查列表中元素的数量是否大于我要求的样本,即:

mysample = []

def rnd(n):
    if len(mysample) < n:
        return False
    return random.sample(mysample, n)

在这种情况下,False如果要求的元素数量大于我们的数量,我会返回.

这是好习惯吗？我们正在调用的地方rnd()是期望返回一个列表,而不是布尔值,所以对我来说感觉不对.

使用以下MWE:

with open('a','w') as f:
    f.write('\r')
with open('a','r') as f:
    print(ord(f.read()))

我得到以下输出:

$ python2 test.py 
13
$ python3 test.py 
10

你能解释一下原因吗？13是\rascii和UTF-8 的预期十进制数,据我所知.

我有一个简单的方法，它接受一个函数来稍后回调：

def SimpleFunc(parm1):
    print(parm1)

class CallMe:
    def __init__(self, func):
        self.func = func

    def Call(self, parm):
        self.func(parm)

caller = CallMe(SimpleFunc)
caller.Call("Hallo")

这很好用！

但我想使用一个类方法，并想在定义的对象上调用该方法作为回调：

class WithClassMethod:
    def __init__( self, val ):
        self.val = val 

    def Func(self, parm):
        print( "WithClass: ", self.val, parm )


obj = WithClassMethod(1)
caller = CallMe( ??? )
caller.Call("Next")

如何将对象/方法对绑定到可调用对象？

注意：来自的代码CallMe不在我的控制之下。它来自需要处理程序功能的网络服务器。

我对Python的奇怪行为感到困惑locals().
基本上我想从locals()词典理解中的字典中获取一个项目,但它失败了.这是一个非常基本的事情,所以:

>>> foo=123
>>> bar=345
>>> baz=678
>>> {k: locals()[k] for k in ('foo','bar','baz')}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <dictcomp>
KeyError: 'foo'
>>> locals()['foo']
123
>>> locale=locals()
>>> {k: locale[k] for k in ('foo','bar','baz')}
{'foo': 123, 'bar': 345, 'baz': 678}
>>> type(locals())
<class 'dict'>
>>> def fun():
...     return {'foo': 123,'bar':345}
... 
>>> {k: fun()[k] for k in ('foo','bar')}
{'foo': 123, 'bar': 345}

在实际方面 …

函数调用总会产生一些开销.但为什么下面的代码显示非函数调用较慢.

码:

import time

def s():
    for i in range(1000000000):
        1 + 1

t = time.time()
s()
print("Function call: " + str(time.time() - t))

t = time.time()
for i in range(1000000000):
    1 + 1
print("Non function call: " + str(time.time() - t))

输出:

Function call: 38.39736223220825
Non function call: 60.33238506317139