相关疑难解决方法(0)

当我运行下面的python代码时,

def main():
    #print prime_factors(10)
    print prime_factors(9)

def prime_factors(n, i=2, factors=[]):
    if n==1:
        return factors
    if(n%i==0):
        factors.append(i)
        n = n/i
        return prime_factors(n, i, factors)
    else:
        return prime_factors(n, i+1, factors)

if __name__ == '__main__':
    main()

它返回预期结果,返回9的素数因子:

[3, 3]

如果我从第2行"print prime_factors(10)"中删除注释,就会发生一些奇怪的事情.对于10,一切都很好,但对于9,它不仅包含9的素数因子,而且包含10的素数因子:

[2, 5]
[2, 5, 3, 3]

如果我用两个可选参数调用该函数

def main():
    print prime_factors(10, i=2, factors[])
    print prime_factors(9, i=2, factors[])

一切正常.

[2,5]
[3,3]

我无法弄清楚为什么.我怀疑这是范围的一些问题,但我只是不明白:-(任何帮助将不胜感激.

让我们说我正在建立各种各样的基本搜索引擎.我有一个字符串列表作为搜索结果,我想在顶部订购具有最佳匹配结果的搜索结果列表.

我当前的代码看起来像这样(命名参数作为示例)

import difflib
def order_by_best_match(search_results=["spam", "eggs", "spammy", "eggy"], search_query="spam"):

    for result in search_results:
        ratio = difflib.SequenceMatcher(None, result, search_query).ratio()

之后我不知道该怎么办ratio.我知道我必须对列表进行排序ratio,但我该怎么做呢？

我定义了一个简单的模型,并在类中添加了一些非SQL相关的属性.

如果属性是int或string类型的东西正在工作.但如果它是字典或列表类型,那么神奇地在模型类的所有不同实例上使用相同的列表.

例:

# Sample model class
class TestClass(Base):
   # SQL Mappings   
   __tablename__ = 'test1'

   pid = Column("id", Integer, primary_key=True)
   name = Column('name', String)

   # Non SQL related attributes
   works_var = 0
   works_not_var = []
   # ...

在查询处理检索到的TestClass实例之后的其他地方

my_test_class.works_not_var.append("testval1")
my_test_class2.works_not_var.append("testval2")

不知何故,两个附加值最终都在同一个列表中:

print id(my_test_class.works_not_var)
print id(my_test_class2.works_not.var)

我的是一样的.但它适用于"works_var".我有不同的.

Python教程4.7.1.默认参数值表示以下内容:

重要警告:默认值仅评估一次.当默认值是可变对象(如列表,字典或大多数类的实例)时,这会有所不同.例如,以下函数累积在后续调用中传递给它的参数:

def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)

Run Code Online (Sandbox Code Playgroud)

这将打印

[1]
[1, 2]
[1, 2, 3]

Run Code Online (Sandbox Code Playgroud)

在内存管理方面,我不太明白"仅评估一次"的含义.显然,函数的默认值在首次调用函数时被计算一次,并且即使在函数结束后也存储在单独的存储器地址中.(根据我的理解,在函数结束后,应该释放所有局部变量？)

我对么？

我想建立一个原型:

def foo(a,t=([0]*len(a))):
  print t

由于目前不重要的原因.我传入的是可变长度列表参数.但是,Linux上的Python 2.7.10总是返回如下:

>>> a = [1,2,3,4]
>>> foo(a)
[O, 0]

没有函数调用,这些都不会以意外的方式运行.是什么导致Python总是认为在foo()中的变量赋值期间传递的列表是长度为2？

我有一个正在一遍又一遍地运行的函数。在该函数内部，我希望仅在该函数第一次运行时运行特定的段。

我不能使用函数外部的任何变量，例如

    firstTime = True

    myFunction(firstTime): #function is inside a loop
        if firstTime == True:
            #code I want to run only once
            firstTime = False
        #code I want to be run over and over again

我也不想使用全局变量。

有什么想法如何实现这一点？

详细说明

sample_dict = {"key1" : {"key2" : "value_of_interest}}

现在我希望能够进行以下调用

val = sample_dict.recursive_get("key2", None)

我可以想到一些有用的案例.例如,从作为JSON的api响应中获取键值.

而且我知道写这样一个函数并不困难,但我的问题是 - 为什么它还没有包括在内？

如果它导致糟糕的设计,请提供一些示例.

def f(x, arr=[]):
    arr.append(x)
    return arr
print(f(1),f(2))

o/p: [1,2] [1,2]

def f(x, arr=[]):
    arr.append(x)
    return arr
print(f(1))
print(f(2))

o/p: [1]
     [1,2]

为什么以不同方式调用函数f()会改变输出值？我编写第二个函数只是为了与第一个函数进行比较.对不起,如果这造成了混乱.

我最近阅读了objgraph文档,我对以下代码感到困惑

>>> class MyBigFatObject(object):
...     pass
...
>>> def computate_something(_cache={}):
...     _cache[42] = dict(foo=MyBigFatObject(),
...                       bar=MyBigFatObject())
...     # a very explicit and easy-to-find "leak" but oh well
...     x = MyBigFatObject() # this one doesn't leak

它表明"非常明显且容易找到'泄漏'".这有内存泄漏吗？这是dict _cache吗？

class abc :
    x = 10
    list = []   
    def __init__(self):
        self.a = 30      
        self.b = 40

a = abc()
b = abc()
a.x = a.x + 1
print a.x
print b.x
a.list.append(1)
print b.list   

Output :
10
11
[1]

所以我们看到它x不是跨对象共享的a,b而是list共享的.有人可以解释这种行为吗？

所以它的答案似乎在于列表是可变的objs而数字不是:

class abc :
   x = 10
   m_list = []

   def __init__(self):
       self.a = 30      
       self.b = 40



a = abc()
b = abc()
print id(a.x)
a.x = a.x + 1 …