3

这涉及将 SAS 中的 2-way 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]

(显然,我只是在这里重用了以前的理解,因为它做了我需要的。编辑:)

我希望这些最终得到相同的数据类型,至少在通过相关因素循环时,可以应用和使用相同的平均值/求和/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([])

分离查询:有没有办法显式强制浅拷贝转换为深拷贝?复制?或者,类似地,当复制到变量中时,有没有办法声明赋值也应该替换指针,而不仅仅是值?(stthe assignment 不会传播到其他浅拷贝)同样,有时使用它也可能很有用,因此能够控制它何时发生或不发生听起来真的很好。(当我准备通过调用插入表格时,我真的踩到了自己: 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 的改进,已经看到代码质量的显着提高。当然,进一步的想法仍然值得赞赏。

4

3 回答 3

6

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

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

我会从左到右处理这个问题。取这四个字:

for sublist in response

我希望你能看到与常规for循环的相似之处。sublist这四个词正在为每个in执行一些操作做基础工作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

于 2010-08-30T05:17:04.963 回答
1

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

于 2010-08-30T05:26:24.807 回答
1

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

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

于 2010-08-30T06:35:52.230 回答