如何从一个文件中读取两行并在forloop中创建动态键

Question

这个问题跟在问题后面：How to read two lines from a file and create dynamics keys in a for-loop?

但是，这个问题的性质已经发展到了我想要解决的某种复杂性。在

以下是我的数据结构用空格隔开。在

chr pos         M1  M2  Mk  Mg1  F1_hybrid     F1_PG    F1_block    S1  Sk1   S2    Sj
2   16229767    T/T T/T T/T G/T C|T 1|0 726  .  T/C T/C T/C
2   16229783    C/C C/C C/C A/C G|C 0|1 726 G/C G/C G/C C|G
2   16229992    A/A A/A A/A G/A G|A 1|0 726 A/A A/A A/A A|G
2   16230007    T/T T/T T/T A/T A|T 1|0 726 A|T A|T A|T A|T
2   16230011    G/G G/G G/G G/G C|G 1|0 726 G/C C|G C|G G/C
2   16230049    A/A A/A A/A A/A T|A 1|0 726 A|T .   A/T A/T
2   16230174    .   .   .   C/C T|C 1|0 726 C|T T|C T|C C|T
2   16230190    A/A A/A A/A A/A T|A 1|0 726 T|G G|T T|G T|G
2   16230260    A/A A/A A/A A/A G|A 1|0 726 G/G G/G G/G G/G

说明：

• 上面的文件中有两大类数据。来自Group M的数据具有以M开头的示例名称，类似地，group S具有多个以S开头的列名称。

• 有一个混合柱（用F1混合表示）。

• 数据是沿着位置线的字符串。F1|混合动力车是用管道（|）来区分这两个字母的。所以，F1中的两个字符串值是C-G-G-A-C-T-T-T-G，而另一个字符串值是T-C-A-T-G-A-C-A-A。其中一个字符串来自M-group，另一个来自S-group，但是我需要做一些统计分析。但是，我可以从视觉上看出T-C-A-T-G-A-C-A-A字符串很可能来自M-group。

程序：

• 我阅读第一行并使用列信息创建一个唯一的键。

• 然后我读了第二行和第三行，以及F1|u hybrid中的值，即C | T和G | C。现在，我需要计算M组和S组之间存在多少GgC（解释为G给定C）和CgT（C给定T）。

• 然后读取第三（G | C）和第四（G | A）线在F1|混合。所以，这两个州是GgG和AgC。同样地，我现在认为M和S组中存在许多GcG和AgC。

因此，我试图构建一个Markov-model，它计算F1阶段字符串的状态数，并以group M和group S中观察到的计数。在

我现在解释，如何根据F1_hyrbid计算任何XgY（X给定Y）的数量：

• 在进行计数之前，请注意这些条件。 现有条件可以是阶段性的（用管道表示）和非相位的（如果if两行至少有一个斜线（/）。在

条件01:

对于第2行和第3行，M1样本的状态为（T/T with C/C）。由于分隔符是一个斜线（/）而不是管道（|），我们无法判断M1样本处于哪个状态。但是，我们可以创建组合矩阵（用于前状态和当前状态）

^{pr2}$

现在，我们可以知道有4个总的CgT

如果这个条件满足，我们继续做同样的矩阵。在

条件02

M组的其他样本也是如此，但Mg1除外，其中G/T在A/C之前。因此，矩阵为：

    G     T
A  AgG   AgT
C  CgG   CgT

所以，这里我们观察到1个CgT计数。在

条件03:

但是，如果在这两种状态下，早期的状态-现在状态都是由管道相控的（如样品Sk1的A | T位于1623007位置，C | G位于16230011位置）我们可以直接计算出该位置观察状态的相态，即只有CgA和GgT，所以CgT的计数为0。在

条件04: 如果一个状态有pipe（|），而另一个有斜杠（/），则条件将与两个有斜杠的状态相同。在

条件05: 如果任何先前的状态或现在的状态是周期（.），则观察计数自动为F1_hybrid预期状态的零（0）。在

所以，预期输出应该是这样的：

pos     M1  M2  Mk  Mg1 H0  H1  S1  Sk1 S2  Sj
16..9783    4-CgT   4-CgT   4-CgT   1-CgT   GgC CgT 0   1-CgT   1-CgT   1-CgT
16..9992    4-AgC   4-AgC   4-AgC   2-AgC   GgG AgC 1-AgC   1-AgC   1-AgC   1-AgC,1-GgG
16..0007    4-TgA   4-TgA   4-TgA   1-AgG,1-TgA AgG TgA 2-TgA   2-TgA   2-TgA1  1-TgA
..................contd

或者，字典格式中每个列的值都是相同的。类似于['4-CgT','4-CgT','4-CgT','4-CgT']在16..9783位置的第一个M1，其他的也一样。在

Answer 1

这个问题有点老，但很有趣，因为你有一个非常清晰的规范，你需要帮助来编写代码。我将按照自顶向下的方法公开一个解决方案，这是一个非常著名的方法，使用普通的老python。适应大熊猫应该不难。在

自上而下的方法对我来说意味着：如果你不知道怎么写，就给它命名吧！

您有一个文件（或字符串）作为输入，并希望输出一个文件（或字符串）。这看起来很简单，但是您需要合并行对来构建每个新行。其理念是：

1. 获取输入的行，作为字典
2. 两人一组
3. 为每一对建立一个新行
4. 输出结果

现在您还不知道如何编写行生成器。你也不知道如何为每一对建立一个新的行。不要被困难所阻碍，只要说出解决办法。假设您有一个函数get_rows和一个函数build_new_row。让我们写下：

def build_new_rows(f):
    """generate the new rows. Output may be redirected to a file"""
    rows = get_rows(f) # get a generator on rows = dictionaries.
    r1 = next(rows) # store the first row
    for r2 in rows: # for every following row
        yield build_new_row(r1, r2) # yield a new row built of the previous stored row and the current row.
        r1 = r2 # store the current row, which becomes the previous row

现在，检查两个“缺少”函数：get_rows和{}。 函数get_rows非常容易编写。主要内容如下：

^{pr2}$

其中process_line只是在空格上拆分行，例如使用re.split("\s+", line.strip())。在

第二部分是build_new_row。仍然是自顶向下的方法：您需要从预期的表中构建H0和H1，然后根据您暴露的条件为每M和S构建H1的计数。假设您有一个计算H0和H1的pipe_compute函数，以及一个为每M和S构建H1计数的build_count函数：

^{3}$

你现在几乎什么都有了。看看pipe_compute：这正是你在条件03中写的。在

def pipe_compute(v1, v2):
    """build H0 H1 according to condition 03"""
    xs = v1.split("|")
    ys = v2.split("|")
    return [ys[0]+"g"+xs[0], ys[1]+"g"+xs[1]]

对于buid_count，坚持自顶向下的方法：

def build_count(v1, v2, to_count):
    """nothing funny here: just follow the conditions"""
    if is_slash_count(v1, v2): # are conditions 01, 02, 04 true ?
        c = slash_count(v1, v2)[to_count] # count how many "to_count" we find in the 2 x 2 table of condtions 01 or 02.
    elif "|" in v1 and "|" in v2: # condition 03
        c = pipe_count(v1, v2)[to_count]
    elif "." in v1 or "." in v2: # condition 05
        return '0'
    else:
        raise Exception(v1, v2)

    return "{}-{}".format(c, to_count) # n-XgY

我们还在往下走。我们什么时候有is_slash_count？两个斜杠（条件01和02）或一个斜杠和一个管子（条件04）：

def is_slash_count(v1, v2):
    """conditions 01, 02, 04"""
    return "/" in v1 and "/" in v2 or "/" in v1 and "|" in v2 or "|" in v1 and "/" in v2

函数slash_count只是条件01和02的2x2表：

def slash_count(v1, v2):
    """count according to conditions 01, 02, 04"""
    cnt = collections.Counter()
    for x in re.split("[|/]", v1): # cartesian product
        for y in re.split("[|/]", v2): # cartesian product
            cnt[y+"g"+x] += 1
    return cnt # a dictionary XgY -> count(XgY)

函数pipe_count更简单，因为您只需计算pipe_compute的结果：

def pipe_count(v1, v2):
    """count according to condition 03"""
    return collections.Counter(pipe_compute(v1, v2))

现在你完蛋了。我得到了这个结果，与你的预期略有不同，但你肯定已经看到我的错误了吗公司名称：

pos M1  M2  Mk  Mg1 H0  H1  S1  Sk1 S2  Sj
16229783    4-CgT   4-CgT   4-CgT   1-CgT   GgC CgT 0   1-CgT   1-CgT   1-CgT
16229992    4-AgC   4-AgC   4-AgC   1-AgC   GgG AgC 2-AgC   2-AgC   2-AgC   1-AgC
16230007    4-TgA   4-TgA   4-TgA   1-TgA   AgG TgA 2-TgA   2-TgA   2-TgA   0-TgA
16230011    4-GgT   4-GgT   4-GgT   2-GgT   CgA GgT 1-GgT   1-GgT   1-GgT   1-GgT
16230049    4-AgG   4-AgG   4-AgG   4-AgG   TgC AgG 1-AgG   0   1-AgG   1-AgG
16230174    0   0   0   4-CgA   TgT CgA 1-CgA   0   1-CgA   1-CgA
16230190    0   0   0   4-AgC   TgT AgC 0-AgC   0-AgC   0-AgC   0-AgC
16230260    4-AgA   4-AgA   4-AgA   4-AgA   GgT AgA 0-AgA   0-AgA   0-AgA   0-AgA

奖金：Try it online!

重要的是，除了这个特定问题的解决方案之外，我所使用的方法以及在软件开发中广泛使用的方法。代码可能会有很大的改进。在