相关疑难解决方法(0)

在Python中将一个可变对象设置为函数中参数的默认值是一个常见的错误.以下是David Goodger撰写的优秀文章中的一个例子:

>>> def bad_append(new_item, a_list=[]):
        a_list.append(new_item)
        return a_list
>>> print bad_append('one')
['one']
>>> print bad_append('two')
['one', 'two']

之所以出现这种情况的解释是在这里.

现在我的问题是:这个语法有一个很好的用例吗？

我的意思是,如果遇到它的每个人都犯了同样的错误,调试它,理解问题,从而试图避免它,这种语法有什么用？

考虑以下代码段:

# directorys == {'login': <object at ...>, 'home': <object at ...>}
for d in directorys:
    self.command["cd " + d] = (lambda : self.root.change_directory(d))

我希望创建一个包含两个函数的字典如下:

# Expected :
self.command == {
    "cd login": lambda: self.root.change_directory("login"),
    "cd home": lambda: self.root.change_directory("home")
}

但看起来生成的两个lambda函数完全相同:

# Result :
self.command == {
    "cd login": lambda: self.root.change_directory("login"),
    "cd home": lambda: self.root.change_directory("login")   # <- Why login ?
}

我真的不明白为什么.你有什么建议吗 ？

假设一个函数具有可变的默认参数：

def f(l=[]):
    l.append(len(l))
    return l

如果我运行此命令：

def f(l=[]):
    l.append(len(l))
    return l
print(f()+["-"]+f()+["-"]+f()) # -> [0, '-', 0, 1, '-', 0, 1, 2]

或这个：

def f(l=[]):
    l.append(len(l))
    return l
print(f()+f()+f()) # -> [0, 1, 0, 1, 0, 1, 2]

代替以下内容，这将更合乎逻辑：

print(f()+f()+f()) # -> [0, 0, 1, 0, 1, 2]

为什么？

我正在编写一个代码,一次取一个巨大的文本文件(几GB)N行,处理该批处理,并移动到下一行N行,直到我完成整个文件.(我不在乎最后一批是不是完美的尺寸).

我一直在阅读有关使用itertools islice进行此操作的信息.我想我在那里:

from itertools import islice
N = 16
infile = open("my_very_large_text_file", "r")
lines_gen = islice(infile, N)

for lines in lines_gen:
     ...process my lines...

麻烦的是我想处理下一批16行,但我遗漏了一些东西

我正在使用PyCharm(Python 3)编写一个Python函数,它接受一个字典作为参数attachment={}.

def put_object(self, parent_object, connection_name, **data):
    ...

def put_wall_post(self, message, attachment={}, profile_id="me"):
    return self.put_object(profile_id, "feed", message=message, **attachment)

在IDE中,attachment={}为黄色.将鼠标移到它上面会显示警告.

默认参数值是可变的

此检查检测何时在参数的默认值中检测到可变值作为列表或字典.

默认参数值仅在函数定义时计算一次,这意味着修改参数的默认值将影响函数的所有后续调用.

这意味着什么,我该如何解决？

可能重复:
Python中的"最小惊讶":可变默认参数

我对Python函数/方法中可选参数的工作原理感到困惑.

我有以下代码块:

>>> def F(a, b=[]):
...     b.append(a)
...     return b
...
>>> F(0)
[0]
>>> F(1)
[0, 1]
>>>

为什么F(1)回归[0, 1]而不是[1]？

我的意思是,里面发生了什么？

我很难理解算法中问题的根本原因.然后,通过逐步简化函数,我发现在Python中对默认参数的评估并不像我预期的那样.

代码如下:

class Node(object):
    def __init__(self, children = []):
        self.children = children

问题是children如果没有明确给出属性,Node类的每个实例都共享相同的属性,例如:

>>> n0 = Node()
>>> n1 = Node()
>>> id(n1.children)
Out[0]: 25000176
>>> id(n0.children)
Out[0]: 25000176

我不明白这个设计决定的逻辑？为什么Python设计者决定在定义时评估默认参数？这对我来说似乎非常违反直觉.

我是一个python初学者,阅读'python tutorial',它说如果我们有一个函数:

def f(a, L=[]):
     L.append(a)
     return L
print f(1)
print f(2)
print f(3)

这将打印

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

因为默认值只计算一次而list是可变对象.我能理解.

它说继续,如果我们不希望在后续调用之间共享默认值,我们可以:

def f(a, L=None):
   if L is None:           #line  2
       L = []            
   L.append(a)
   return L
print f(1)            
print f(2)
print f(3)

这将输出:

[1]
[2]
[3]

但为什么呢？怎么解释这个.我们知道默认值只是被评估once,当我们调用f(2)时,L不是None而且if(第2行)不能为真,所以L.append(a)== [1,2].我可以猜出由于某种原因再次评估默认值,但是什么是'某种原因',只是因为python解释器看到了if L is None: L = []

我想通过使用getattr函数添加参数来调用一些未知函数.可能吗？

只是好奇,

使用len()或def __len__()构建课程之间有什么区别(优点和缺点)？哪个是最好的Python风格？

   class foo(object):
      def __init__(self,obs=[])
         self.data = obs
         self.max = max(obs)
         self.min = min(obs)
         self.len = len(obs)

要么

   class foo(object):
      def __init__(self,obs=[])
         self.data = obs
         self.max = max(obs)
         self.min = min(obs)
      def __len__(self):
         return len(self.data)