Question

这涉及将SAS中的双向ANOVA程序转换为Python的项目。

我几乎开始尝试学习周四的语言，所以我知道我还有很大的提升空间。如果我遗漏一些明显的东西，请务必告诉我。我还没有Sage运行起来，也没有numpy，所以现在，这都是非常普通的Python 2.6.1。（便携式）

主查询：需要一组良好的列表推导，这些列表推导可以按因子A，因子B，整体以及因子A和B（AxB）的每个级别的组中提取列表中样本列表中的数据。 / p>

经过一些工作后，数据采用以下形式（3层嵌套列表）：

反应[A] [B] [N]

（意为[a1 [b1 [n1，...，nN] ... [bB [n1，... nN]]]，...，[aA [b1 [n1，...，nN] ] ... [bB [n1，... nN]]] 希望这很清楚。）

我的例子中的因子水平：A = 3（0-2），B = 8（0-7），N = 8（0-7）

byA= [[a[i] for i in range(b)] for a[b] in response]

（有人可以解释为什么这种语法有效吗？我偶然发现它试图看看解析器会接受什么。我没有看到那种语言附加到其他地方，但它真的很好。关于该主题的网站或书籍上的任何良好链接都将受到赞赏。编辑：运行之间变量的持久性解释了这种奇怪。它不起作用。）

byB=lstcrunch([[Bs[i] for i in range(len(Bs)) ]for Bs in response])

（值得注意的是zip(*response)几乎可以做我想要的。上面的版本实际上并没有工作，我记得。我还没有经过仔细测试。）

byAxB= [item for sublist in response for item in sublist]

（Alex Martelli在本网站上的回复中被盗。再次有人可以解释为什么？列表理解语法在我读过的文本中没有得到很好的解释。）

ByO= [item for sublist in byAxB for item in sublist]

（显然，我只是重复使用前面的理解，因为它做了我需要的。编辑：）

我希望它们能够以相同的数据类型结束，至少在被相关因素循环时，s.t。可以应用和使用相同的平均值/总和/ SS /等等函数。

这很容易被更清洁的东西取代：

def lstcrunch(Dlist):
    """Returns a list containing the entire
    contents of whatever is imported,
    reduced by one level.

    If a rectangular array, it reduces a dimension by one.
    lstcrunch(DataSet[a][b]) -> DataOutput[a]
    [[1, 2], [[2, 3], [2, 4]]] -> [1, 2, [2, 3], [2, 4]]
    """
    flat=[]
    if islist(Dlist):#1D top level list
        for i in Dlist:
            if islist(i):
                flat+= i
            else:
                flat.append(i)
        return flat
    else:
        return [Dlist]

哦，当我谈论这个主题时，将变量识别为列表的首选方法是什么？我一直在使用：

def islist(a):
    "Returns 'True' if input is a list and 'False' otherwise"
    return type(a)==type([])

分手查询：有没有办法明确强制浅拷贝转换为深？复制？或者，类似地，当复制到变量时，有没有办法声明赋值也应该替换指针，而不仅仅是值？（s.t.赋值不会传播到其他浅层副本）同样，使用它也可能是有用的，有时，所以能够控制它何时发生或不发生声音真的很好。（当我通过调用准备我的表格插入时，我真的全身心投入：响应= [[[0] * N] * B * A ）

修改：进一步调查导致大部分工作正常。我已经上课并测试了它。它工作正常。我将保留列表理解表格以供参考。

def byB(array_a_b_c):
    y=range(len(array_a_b_c))
    x=range(len(array_a_b_c[0]))
    return [[array_a_b_c[i][j][k]
    for k in range(len(array_a_b_c[0][0]))
    for i in y]
    for j in x]


def byA(array_a_b_c):
    return [[repn for rowB in rowA for repn in rowB] 
    for rowA in array_a_b_c]

def byAxB(array_a_b_c):
    return [rowB for rowA in array_a_b_c 
    for rowB in rowA]

def byO(array_a_b_c):
    return [rep
    for rowA in array_a_b_c
    for rowB in rowA
    for rep in rowB]


def gen3d(row, col, inner):
"""Produces a 3d nested array without any naughty shallow copies.

[row[col[inner]] named s.t. the outer can be split on, per lprn for easy display"""
    return [[[k for k in range(inner)]
    for i in range(col)]
    for j in range(row)]

def lprn(X):
    """This prints a list by lines.

    Not fancy, but works"""
    if isiterable(X):
        for line in X: print line
    else:
        print x

def isiterable(a):
    return hasattr(a, "__iter__")

感谢所有回复的人。由于我的gnosis改进，已经看到代码质量明显改善。当然，还有进一步的想法。

Answer 1

byAxB= [item for sublist in response for item in sublist]有人可以解释为什么吗？

我相信A.M.能够给你一个很好的解释。这是我在等待他出现时的刺痛。

我会从左到右接近这个。拿这四个字：

for sublist in response

我希望您能看到与常规for循环的相似之处。这四个单词正在为sublist中的每个response执行某些操作而开展工作。 response似乎是一个列表列表。在这种情况下，sublist将是response每次迭代的列表。

for item in sublist

这又是另一个for循环。鉴于我们在前一个“循环”中第一次听说sublist，这表明我们现在遍历子列表，一次item。如果我在没有理解的情况下编写这些循环，它将如下所示：

for sublist in response:
    for item in sublist:

接下来，我们来看看剩余的单词。 [，item和]。这实际上意味着，收集列表中的项目并返回结果列表。

每当您在创建或理解列表迭代时遇到问题，请先写出相关的for循环，然后压缩它们：

result = []

for sublist in response:
    for item in sublist:
        result.append(item)

这将压缩为：

[
    item 
    for sublist in response
    for item in sublist
]

列表理解语法在我读过的文本中没有得到很好的解释

Dive Into Python有section致力于列表推导。还有一个很好的tutorial可供阅读。

<强>更新

我忘了说点什么。列表推导是实现传统上使用map和filter完成的内容的另一种方式。如果你想要提高你的理解力，那么理解map和filter的工作方式是个好主意。

Answer 2

对于复制部分，查看复制模块，python只是在创建第一个对象后使用引用，因此其他“副本”中的任何更改都会传播回原始文件，但复制模块会生成对象的真实副本可以指定几种复制模式

Answer 3

在您的数据结构中产生正确级别的递归有时会很奇怪，但我认为在您的情况下它应该相对简单。为了在我们做的时候测试它，我们需要一个样本数据，比如说：

data = [ [a,
          [b,
           range(1,9)]]
         for b in range(8)
         for a in range(3)]
print 'Origin'
print(data)
print 'Flat'
## from this we see how to produce the c data flat
print([(a,b,c) for a,[b,c] in data])    
print "Sum of data in third level = %f" % sum(point for point in c for a,[b,c] in data)
print "Sum of all data = %f" % sum(a+b+sum(c) for a,[b,c] in data)

对于类型检查，通常你应该避免它，但如果你必须，因为当你不想在字符串中进行递归时你就可以这样做

if not isinstance(data, basestring) : ....

如果您需要展平结构，可以在Python documentation中找到有用的代码（其他表达方式为chain(*listOfLists))和列表理解[ d for sublist in listOfLists for d in sublist ]：

from itertools import flat.chain
def flatten(listOfLists):
    "Flatten one level of nesting"
    return chain.from_iterable(listOfLists)

如果您有不同深度的数据，这不起作用。对于重量较重的扁平剂，请参阅：http://www.python.org/workshops/1994-11/flatten.py，

Python列表理解和其他更好的实践

3 个答案: