相关疑难解决方法(0)

假设我在python中有这两段代码:

1 --------------------------
import numpy as np
x = np.array([1,2,3,4])
y = x
x = x + np.array([1,1,1,1])
print y

2 --------------------------
import numpy as np
x = np.array([1,2,3,4])
y = x
x += np.array([1,1,1,1])
print y

我认为y两个例子中的结果都是相同的,因为y指出x并x成为(2,3,4,5),但事实并非如此

结果是(1,2,3,4) for 1和(2,3,4,5) for 2.

经过一些研究,我发现在第一个例子中

#-First example---------------------------------------
x = np.array([1,2,3,4]) # create x --> [1,2,3,4] 
y = x                   # made y point to x …

我想通过命令行使用这种参数调用python脚本(列表可以是任何大小,例如3):

python test.py --option1 ["o11", "o12", "o13"] --option2 ["o21", "o22", "o23"]

使用点击.从文档中,我们无法在任何地方声明我们可以使用列表作为@ click.option的参数

当我尝试这样做时:

#!/usr/bin/env python
import click

@click.command(context_settings=dict(help_option_names=['-h', '--help']))
@click.option('--option', default=[])
def do_stuff(option):

    return

# do stuff
if __name__ == '__main__':
    do_stuff()

在我的test.py,通过从命令行调用它:

python test.py --option ["some option", "some option 2"]

我收到一个错误:

错误:得到意外的额外参数(某些选项2))

我不能真正使用可变参数,因为每个命令只允许1个可变参数(http://click.pocoo.org/5/arguments/#variadic-arguments)

因此,如果有人能指出我正确的方向(最好使用点击),我将非常感激.

test.py中的代码:

class Base(object):
    def __init__(self, l=[]):
        self.l = l

    def add(self, num):
        self.l.append(num)

    def remove(self, num):
        self.l.remove(num)

class Derived(Base):
    def __init__(self, l=[]):
        super(Derived, self).__init__(l)

Python shell会话:

Python 2.6.5 (r265:79063, Apr  1 2010, 05:22:20) 
[GCC 4.4.3 20100316 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import test
>>> a = test.Derived()
>>> b = test.Derived()
>>> a.l
[]
>>> b.l
[]
>>> a.add(1)
>>> a.l
[1]
>>> b.l
[1]
>>> c = test.Derived()
>>> c.l
[1] …

我有一个非常基本的问题.

假设我调用一个函数,例如,

def foo():
    x = 'hello world'

如何让函数以这样的方式返回x,我可以将它用作另一个函数的输入或者在程序体内使用变量？

当我使用return并在另一个函数中调用该变量时,我得到一个NameError.

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

谁能解释以下奇怪的行为？

我有以下课程:

class Zoo:
    def __init__(self,alist=[]):
        self.animals = alist

    def __len__(self):
        return len(self.animals)

    def add(self,a):
        self.animals.append(a)

当我做以下事情时,

In [38]: z=Zoo()
In [39]: z.add(2)
In [40]: z.add(23)
In [41]: len(z)
Out[41]: 2

In [42]: z2=Zoo()

In [43]: len(z2)
Out[43]: 2

为什么z2.animals不是空列表？

谢谢,马蒂亚斯

我正在尝试创建一个可能作为输入接收多个或几个字典的函数.我正在使用以下代码:

def merge_many_dics(dic1,dic2,dic3=True,dic4=True,dic5=True,dic6=True,dic7=True,dic8=True,dic9=True,dic10=True):
"""
Merging up to 10 dictionaries with same keys and different values
:return: a dictionary containing the common dates as keys and both values as values
"""
manydics = {}
for k in dic1.viewkeys() & dic2.viewkeys() & dic3.viewkeys() & dic4.viewkeys() & dic5.viewkeys() & dic6.viewkeys()\
        & dic7.viewkeys() & dic8.viewkeys() & dic9.viewkeys() & dic10.viewkeys():
    manydics[k] = (dic1[k], dic2[k],dic3[k],dic4[k],dic5[k],dic6[k],dic7[k],dic8[k],dic9[k],dic10[k])

return manydics

请注意,我试图将参数dic3,dic4,dic5等等于"True",因此当它们未被指定并且在函数中被调用时,没有任何反应.但是我收到以下错误:

Traceback (most recent call last):
File "/Users/File.py", line 616, in <module>
main_dic=merge_many_dics(dic1,dic2,dic3,dic4)
File "/Users/File.py", line 132, in merge_many_dics …

我注意到以下几点:

class c:
  def __init__(self, data=[]):
    self._data=data
a=c()
b=c()
a._data.append(1)
print b._data
[1]

这是正确的行为吗？

我写了一个小片段来计算给定节点的路径长度(例如它到根节点的距离):

def node_depth(node, depth=0, colored_nodes=set()):
    """
    Return the length of the path in the parse tree from C{node}'s position
    up to the root node. Effectively tests if C{node} is inside a circle
    and, if so, returns -1.

    """
    if node.mother is None:
        return depth
    mother = node.mother
    if mother.id in colored_nodes:
        return -1
    colored_nodes.add(node.id)
    return node_depth(mother, depth + 1, colored_nodes)

现在这个函数发生了一件奇怪的事情(至少对我来说很奇怪):第一次调用node_depth会返回正确的值.但是,使用相同节点第二次调用它会返回-1.coloured_nodes集在第一次调用中为空,但包含第二次调用中已在第一次调用期间添加的所有节点ID:

print node_depth(node) # -->  9
# initially colored nodes --> set([])
print node_depth(node) # --> -1
# initially colored …

我有一个问题,如何创建一个子列表(我希望这是正确使用的术语)从给定的列表,而不是复制.

切片似乎可以创建子列表,但是可以通过复制来实现.这是一个例子.

In [1]: a = [1,2,3]

In [2]: id(a)
Out[2]: 4354651128

In [3]: b = a[0:2]

In [4]: b
Out[4]: [1, 2]

In [5]: id(b)
Out[5]: 4354621312

In [6]: id(a[0:2])
Out[6]: 4354620880

在这里看到b的id和[0:2]是不同的,尽管它们的值是相同的.要仔细检查,更改a中的值,b中的值不会更改.

In [7]: a[1] = 4

In [8]: a
Out[8]: [1, 4, 3]

In [9]: b
Out[9]: [1, 2]

所以回到我的问题,如何创建子列表但不复制？我的意思是,当a [1]的值设置为4时,b将为[1,4].

我四处搜索并没有找到太多帮助(也许我没有使用正确的关键字).谢谢!

编辑:

谢谢大家的意见和答案!这是我学到的.

• Python中没有内置的方法来创建列表视图(或创建子列表而不复制).
• 最简单的方法是使用numpy数组.
• 虽然numpy数组与list相比对数据类型有限制,但它确实符合我的目的(实现没有额外内存的quicksort)

这是与numpy数组相同的过程.

In [1]: import numpy as np

In [2]: a = np.arange(1,4)

In [3]: a
Out[3]: array([1, 2, 3])

In …

假设我有3种不同的字典：

dict1 = {
  "A": "a"
}

dict2 = {
  "B": "b", 
  "C": "c",
  "D": "d", 
  "E": "e"
}

dict3 = {
  "F": "f", 
  "G": "g"
}

我想计算这些字典（不含之间的产品的产品dict2和dict3），并结合了其中的键被连接与键和值_与值' and '

所需的输出将是一个字典：

{
  # dict1 x dict2 
  "A_B": "a and b", 
  "A_C": "a and c",
  "A_D": "a and d",
  "A_E": "a and e",

  # dict1 x dict3  
  "A_F": "a and f",
  "A_G": "a and g",

  # dict1 x dict2 x dict3 
  "A_B_F": "a and …