相关疑难解决方法(0)

我对下面的简单程序有疑问:

def my_function(my_array = np.zeros(0)):
    my_array = [1, 2, 3]

my_array = np.zeros(0)
my_function(my_array)
print my_array

它打印一个空数组,好像my_array是通过复制传递而不是通过函数内部的引用传递.怎么纠正？

我有一个运行循环的python脚本.在这个循环中,DoDebugInfo每个循环迭代调用一次该函数.此功能基本上使用matplotlib将一些图片打印到硬盘,导出KML文件并进行其他一些计算,并且不返回任何内容.

我遇到了python的问题,对于每次运行,该函数都会DoDebugInfo占用越来越多的RAM.我猜一些变量正在增加每个循环的大小.

我在通话前后添加了以下几行:

print '=== before: ' + str(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)
DoDebugInfo(inputs)
print '=== after: ' + str(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000)

输出是:

=== before: 71598.08
=== after: 170237.952
=== before: 170237.952
=== after: 255696.896
=== before: 255696.896
=== after: 341409.792

正如您所看到的,在调用之前程序具有内存占用,并且在调用之后它会增加,但在下一次调用之前保持稳定.

为什么是这样？因为DoDebugInfo(inputs)是一个什么都不返回的函数,一些变量如何留在内存中呢？是否需要清除函数末尾的所有变量？

编辑:DoDebugInfo导入此功能:

def plot_line(x,y,kind,lab_x,lab_y,filename):
    fig = plt.figure(figsize=(11,6),dpi=300)
    ax = fig.add_subplot(111)
    ax.grid(True,which='both')
    #print 'plotting'
    if type(x[0]) is datetime.datetime:
        #print 'datetime detected'
        ax.plot_date(matplotlib.dates.date2num(x),y,kind)
        ax.fmt_xdata = DateFormatter('%H')
        ax.autoscale_view()
        fig.autofmt_xdate()
    else:   
        #print 'no datetime' …

当我运行下面的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)

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

我对么？

我正在尝试使用 Python 实现遍历所有图顶点的任意路径（不一定是循环）的递归搜索。这是我的代码：

def hamilton(G, size, pt, path=[]):
    if pt not in set(path):
        path.append(pt)
        if len(path)==size:
            return path
        for pt_next in G[pt]:
            res_path = [i for i in path]
            hamilton (G, size, pt_next, res_path)

这里，pt是起点，path是之前遍历过的所有顶点的列表，不包括pt，默认为空。问题是，每当找到这样的路径时，返回语句都会引用过程的某些内部调用，因此程序不会终止或返回该路径。

例如，获取G = {1:[2,3,4], 2:[1,3,4], 3:[1,2,4], 4:[1,2,3]}（即完整的 4 图）并运行hamilton(G,4,1,[])。它返回None，但如果您打印路径而不是将其作为值返回，您会发现它实际上找到了从 1 开始的所有六个路径。

如果我告诉程序将路径与 return 语句一起打印，它最终会打印所有此类路径，因此运行时间比需要的时间长得多。

如何修复代码，以便在找到第一个合适的路径后终止执行？

我们都知道'可怕的可变默认参数'

我惊讶地发现至少有一个使用可变默认参数的内置函数deepcopy(和相关的__deepcopy__).

def deepcopy(x, memo=None, _nil=[]):

资源

这只是模块作者的一个忽视,还是有一些特殊deepcopy的行为证明了这一点？

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()会改变输出值？我编写第二个函数只是为了与第一个函数进行比较.对不起,如果这造成了混乱.

我有以下递归关系H（n）= 2 * H（n-1）+ 1，H（1）=1。如果我要在python中创建递归函数，它将如何？我尝试了以下操作，但似乎不起作用

def rec_func(N, n=0, H=[])
    if n == 1:
        return [1] + H
    else:

        return rec_fun(N-1, n+1, H)

我可能会完全不高兴，但是任何提示将不胜感激。应该返回元素列表[H(1), H(2),...H(N)]

请注意， n=0, H=[]构造函数中的是必须的。这是我的教科书“数值分析”中的一项练习