Python的列表推导和其他更好的实践

Question

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

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

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

完成一些工作后，数据采用以下形式（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]

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

我希望它们能够以相同的数据类型结束相同的数据类型，至少在有问题的因素循环时，可以应用和使用相同的平均值/ sum / SS / et cetera函数。

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

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([])

分手查询：有没有办法明确强制浅拷贝转换为深？ 复制？ 或者，类似地，当复制到变量时，有没有办法声明赋值也应该替换指针，而不仅仅是值？ （分配不会传播到其他浅层副本）同样，使用它也可能是有用的，不时，所以能够控制它何时发生或不发生声音真的很好。 （当我通过调用准备我的表格插入时，我真的全身心投入：response = [[[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]再次有人可以解释原因吗？

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

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

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有一个专门用于列表推导的部分 。 还有这个很好的教程可供阅读。

更新

我忘了说些什么。 列表推导是实现传统上使用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文档中找到有用的代码（表达它的其他方式是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 ，