这个问题跟在问题后面：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_Hybrid表示）。
数据是沿着位置线的字符串。F1_混合动力车是用管道（）来区分两个字母的。所以，来自f1的两个字符串值是
C-G-G-A-C-T-T-T-G，而另一个字符串值是t-c-a-t-g-a-c-a-a。这个字符串中的一个来自m组，另一个来自s组，但我需要做一些统计分析。但是，我可以从视觉上看出，T-C-A-T-G-A-C-A-A字符串最有可能来自M-Group。程序：
我阅读了第一行，并使用列信息创建了一个唯一的键。
然后我读取第二行和第三行以及f1_hybrid中的值，即c_t与g_c之间的值。现在，我需要计算m组与s组之间存在多少ggc（解释为g给定c）与cgt（c给定t）。
然后读取f1_hybrid中第3行（g_c）和第4行（g_a）。因此，各州是GGG和AGC。同样地，我现在统计出M和S组中存在许多GCG和AGC。
因此，我尝试构建一个
Markov-model来计算从f1开始的相控阵串的状态数，并将观察到的计数取为group Mvsgroup S。我现在解释，如何计算基于f1的任何xgy（x给定y）的数目：
在进行计数之前，必须注意条件。
现有条件可以是分阶段的（用有管道表示）和无相位的（如果if两行至少有一个斜线（/）。
条件01：
对于第2行和第3行，
M1样本的状态为（t/t和c/c）。由于分隔符是斜线（/）而不是管道（），我们无法确定M1样本处于哪个确切状态。但是，我们可以创建组合矩阵（对于以前的状态和现在的状态） T T
C CgT CgT
C CgT CgT
现在，我们可以知道总共有4个CGT
如果这个条件满足，我们继续做同样的矩阵。
条件02
M组的其他样本也是如此，除了MG1，其中G/T在A/C之前。因此，矩阵为：
G T
A AgG AgT
C CgG CgT
在这里我们观察到1个CGT计数。
条件03：
但是，如果两个状态中的早期状态-当前状态都是通过管道分阶段的（例如，对于样本SK1，在16230007位置A_T，在16230011位置C_G），我们可以直接计算该位置的观察状态相态，即只有CGA和GGT，所以CGT的计数为0。
条件04：
如果一个状态有管道（），而另一个状态有斜线（/），则条件将与两个状态都有斜线相同。
条件05：
如果以前的状态或现在的状态中有任何一个是句点（.），则观察计数将自动为零（0），表示预期的F1混合型状态。
所以，预期的输出应该是这样的：
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
或者，每个列的字典格式的值将同样有效。类似于16..9783位置的第一个M1的
['4-CgT','4-CgT','4-CgT','4-CgT']和其他位置的相同。 最佳答案
这个问题有点老，但很有趣，因为您有一个非常清晰的规范，并且需要帮助编写代码。我将按照自顶向下的方法公开一个解决方案，这是一个非常有名的方法，使用普通的旧Python。适应大熊猫并不难。
自上而下的方法对我来说意味着：如果你不知道怎么写，就给它命名吧！
您有一个文件（或字符串）作为输入，并且您想要输出一个文件（或字符串）。这看起来很简单，但是您希望合并成对的行来构建每一个新行。其理念是：
获取输入的行，作为字典
两个人带走
为每对新建一行
输出结果
现在您还不知道如何编写行生成器。您也不知道如何为每对创建一个新行。不要被困难所阻碍，只要说出解决办法。假设你有一个函数和一个函数。让我们写下：
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和build_new_row。函数
get_rows非常容易编写。主要内容如下：header = process_line(next(f))
for line in f:
yield {k:v for k,v in zip(header, process_line(line))}
其中，
build_new_row只是拆分空间上的线，例如使用get_rows拆分。第二部分是
process_line。仍然是自上而下的方法：您需要根据预期的表构建h0和h1，然后根据您暴露的条件为每m和s构建h1的计数。假设您有一个计算h0和h1的re.split("\s+", line.strip())函数，以及一个为每个m和s构建h1计数的build_new_row函数：def build_new_row(r1, r2):
"""build a row"""
h0, h1 = pipe_compute(r1["F1_hybrid"], r2["F1_hybrid"])
# initialize the dict whith the pos, H0 and H1
new_row = {"pos":r2["pos"], "H0":h0, "H1":h1}
for key in r1.keys():
if key[0] in ("M", "S"):
new_row[key] = build_count(r1[key], r2[key], h1)
return new_row
你现在几乎拥有了一切。请看一下：这正是您在条件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]]
对于
pipe_compute，请坚持自上而下的方法：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
我们还在往下走。我们什么时候有？两个斜线（条件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
函数
build_count只是条件01和02的2 x 2表：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_compute更简单，因为您只需计算buid_count的结果：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!
重要的是，除了解决这个特定问题之外，我使用的方法在软件开发中广泛使用。代码可能会改进很多。