用python总结2个文本文件

我有两个大的文本文件，如下面的小例子。有两个文件（主要文件和次要文件）。在主文件和次文件中都有4列。在主文件中，第2列和第3列之间的差异为10000，第2列和第3列之间的差异为32或31，或者接近31的数字，但不太高

主要文件的小示例：

chr4    530000  540000  0.0
chr4    540000  550000  1719.0
chr4    550000  560000  0.0

次要文件的小示例：

chr4    295577  295608  12
chr4    323326  323357  10
chr4    548873  548904  32
chr4    548873  548904  20
chr4    549047  549078  32
chr4    549047  549078  20
chr4    549137  549168  32
chr4    549137  549168  20
chr4    549181  549212  32
chr4    549181  549212  20
chr4    549269  549300  22
chr4    549269  549300  381
chr4    549269  549300  67
chr4    549269  549300  89
chr4    549269  549300  95
chr4    549269  549300  124
chr4    549269  549300  149
chr4    549269  549300  87
chr4    549269  549300  33
chr4    549269  549300  65
chr4    549269  549300  68
chr4    549269  549300  190
chr4    549269  549300  20
chr4    549355  549386  32
chr4    549355  549386  20
chr4    549443  549474  16
chr4    705810  705841  10
chr4    846893  846924  28

我想制作一个新的文本文件，其中有4列。与预期输出类似：

chr4    548873  548904  32  chr4    540000  550000
chr4    548873  548904  20  chr4    540000  550000
chr4    549047  549078  32  chr4    540000  550000
chr4    549047  549078  20  chr4    540000  550000
chr4    549137  549168  32  chr4    540000  550000
chr4    549137  549168  20  chr4    540000  550000
chr4    549181  549212  32  chr4    540000  550000
chr4    549181  549212  20  chr4    540000  550000
chr4    549269  549300  22  chr4    540000  550000
chr4    549269  549300  381 chr4    540000  550000
chr4    549269  549300  67  chr4    540000  550000
chr4    549269  549300  89  chr4    540000  550000
chr4    549269  549300  95  chr4    540000  550000
chr4    549269  549300  124 chr4    540000  550000
chr4    549269  549300  149 chr4    540000  550000
chr4    549269  549300  87  chr4    540000  550000
chr4    549269  549300  33  chr4    540000  550000
chr4    549269  549300  65  chr4    540000  550000
chr4    549269  549300  68  chr4    540000  550000
chr4    549269  549300  190 chr4    540000  550000
chr4    549269  549300  20  chr4    540000  550000
chr4    549355  549386  32  chr4    540000  550000
chr4    549355  549386  20  chr4    540000  550000
chr4    549443  549474  16  chr4    540000  550000

前4列来自次要文件，后3列来自主要文件

第2列和第3列（来自次要文件）中的数字在同一行的范围内，但第6列和第7列（来自主要文件）和第1列等于第5列（实际上是主要文件和次要文件的第1列）

我想查找次要文件中的行，其中第一列等于主要文件的第一列，并且同一行（次要文件中）的第二列和第三列必须在主要文件的第二列和第三列的范围内

因此，实际上，次要文件中的每一行都有3个条件可以包含在输出文件中

最后3列来自主文件，与次文件中的行相匹配

我试图用Python实现这一点，并编写了以下代码，但它没有返回我所期望的结果：

major = open("major.txt", 'rb')
minor = open("minor.txt", 'rb')
major_list = []
minor_list = []
for m in major:
    major_list.append(m)

for n in minor:
    minor_list.append(n)

final = []
for i in minor_list:
    for j in major_list
        if minor_list[i] == major_list[j] and minor_list[i+1] <= major_list[j+1] and minor_list[i+2] >= major_list[j+2]:
        final.append(i)


with open('output.txt', 'w') as f:
    for item in final:
        f.write("%s\n" % item)

major=open（“major.txt”，“rb”）
minor=open（“minor.txt”，“rb”）
专业清单=[]
次要清单=[]
主修文学硕士：
主列表。附加（m）
对于n小调：
次要列表。附加（n）
最终=[]
对于小调清单中的i：
对于专业列表中的j
如果次要清单[i]==主要清单[j]和次要清单[i+1]=主要清单[j+2]：
最后。附加（i）
将open（'output.txt'，'w'）作为f：
最后一项：
f、 写入（“%s\n”%item）

您好，根据我对您的逻辑的理解，我认为下面的代码应该让您走上正确的方向，希望这能有所帮助

import re

# read in files
with open("major.txt") as f:
    major = [x.strip("\n") for x in f.readlines()]

with open("minor.txt") as f:
    minor = [x.strip("\n") for x in f.readlines()]

# split into list of lists
p = re.compile(" +")
major = list(map(lambda x: p.split(x), major))
minor = list(map(lambda x: p.split(x), minor))

with open("output.txt", "w") as out:
    # uses the fact that the lists of lists contain 4 ite
    for major_col1, major_col2, major_col3, major_col4 in major:
        for minor_col1, minor_col2, minor_col3, minor_col4 in minor:
            if major_col1 == minor_col1:
                if int(major_col2) < int(minor_col2) and \
                   int(major_col2) < int(minor_col3) and \
                   int(major_col3) > int(minor_col2) and \
                   int(major_col3) > int(minor_col3):
                   out.write("{0:<10} {1:^8} {2:^8} {3:<8} {4:<10} {5:^8} {6:^}\n"
                             .format(minor_col1, minor_col2,
                                     minor_col3, minor_col4,
                                     major_col1, major_col2, 
                                     major_col3))

重新导入
#读入文件
以open（“major.txt”）作为f：
major=[x.strip（“\n”）表示f.readlines（）中的x
以open（“minor.txt”）作为f：
次要=[x.strip（“\n”）表示f.readlines（）中的x
#拆分为列表列表
p=重新编译（“+”）
主要=列表（图（λx:p.split（x），主要））
次要=列表（图（λx:p.split（x），次要））
打开（“output.txt”、“w”）作为输出：
#使用列表列表包含4个ite的事实
对于主修课程1、主修课程2、主修课程3、主修课程4：
对于小调中的小调1、小调2、小调3、小调4：
如果主列=次列：
如果int（主列2）整数（小整数）和\
整数（大调）>整数（小调）：
out.write（“{0:Hi elly根据我对您的逻辑的理解，我认为下面的代码应该会让您走上正确的方向，希望这会有所帮助

import re

# read in files
with open("major.txt") as f:
    major = [x.strip("\n") for x in f.readlines()]

with open("minor.txt") as f:
    minor = [x.strip("\n") for x in f.readlines()]

# split into list of lists
p = re.compile(" +")
major = list(map(lambda x: p.split(x), major))
minor = list(map(lambda x: p.split(x), minor))

with open("output.txt", "w") as out:
    # uses the fact that the lists of lists contain 4 ite
    for major_col1, major_col2, major_col3, major_col4 in major:
        for minor_col1, minor_col2, minor_col3, minor_col4 in minor:
            if major_col1 == minor_col1:
                if int(major_col2) < int(minor_col2) and \
                   int(major_col2) < int(minor_col3) and \
                   int(major_col3) > int(minor_col2) and \
                   int(major_col3) > int(minor_col3):
                   out.write("{0:<10} {1:^8} {2:^8} {3:<8} {4:<10} {5:^8} {6:^}\n"
                             .format(minor_col1, minor_col2,
                                     minor_col3, minor_col4,
                                     major_col1, major_col2, 
                                     major_col3))

重新导入
#读入文件
以open（“major.txt”）作为f：
major=[x.strip（“\n”）表示f.readlines（）中的x
以open（“minor.txt”）作为f：
次要=[x.strip（“\n”）表示f.readlines（）中的x
#拆分为列表列表
p=重新编译（“+”）
主要=列表（图（λx:p.split（x），主要））
次要=列表（图（λx:p.split（x），次要））
打开（“output.txt”、“w”）作为输出：
#使用列表列表包含4个ite的事实
对于主修课程1、主修课程2、主修课程3、主修课程4：
对于小调中的小调1、小调2、小调3、小调4：
如果主列=次列：
如果int（主列2）整数（小整数）和\
整数（大调）>整数（小调）：
out.write（“{0:我不确定我是否完全实现了您对代码的目标，因此我可能已经更改了一些您必须更改的内容，但这应该会有所帮助—下面的代码段将输出所需的输出

major = open("major.txt", "r")
minor = open("minor.txt", "r")
major_list = []
minor_list = []
for m in major:
    major_list.append(m)

for n in minor:
    minor_list.append(n)

final = []
for i in range(0, len(minor_list)):  # to iterate using the index
    for j in range(0, len(major_list)):

        minor_row = minor_list[i]
        major_row = major_list[j]

        minor_columns = minor_row.split()
        major_columns = major_row.split()

        minor_symbol = minor_columns[0]
        major_symbol = major_columns[0]

        if minor_symbol == major_symbol:
            minor_second_col = int(minor_columns[1])
            minor_third_col = int(minor_columns[2])
            min_range = int(major_columns[1])
            max_range = int(major_columns[2])

            if (minor_second_col <= max_range and minor_second_col >= min_range
                and minor_third_col <= max_range and minor_third_col >= min_range):
                new_line = minor_row.rstrip("\n") + " " + str(major_symbol) + " " + str(min_range) + " " + str(max_range)
                final.append(new_line)


with open("output.txt", "w") as f:
    for item in final:
        f.write("%s\n" % item)

分裂函数在有空格的行中打断字符串，并以字符串列表的形式返回结果。请查看文档，我认为这将有助于退出。
我不确定我是否完全实现了代码的目标，因此我可能已经更改了一些您必须更改的内容，但这应该会有所帮助-下面的代码输出所需的输出

major = open("major.txt", "r")
minor = open("minor.txt", "r")
major_list = []
minor_list = []
for m in major:
    major_list.append(m)

for n in minor:
    minor_list.append(n)

final = []
for i in range(0, len(minor_list)):  # to iterate using the index
    for j in range(0, len(major_list)):

        minor_row = minor_list[i]
        major_row = major_list[j]

        minor_columns = minor_row.split()
        major_columns = major_row.split()

        minor_symbol = minor_columns[0]
        major_symbol = major_columns[0]

        if minor_symbol == major_symbol:
            minor_second_col = int(minor_columns[1])
            minor_third_col = int(minor_columns[2])
            min_range = int(major_columns[1])
            max_range = int(major_columns[2])

            if (minor_second_col <= max_range and minor_second_col >= min_range
                and minor_third_col <= max_range and minor_third_col >= min_range):
                new_line = minor_row.rstrip("\n") + " " + str(major_symbol) + " " + str(min_range) + " " + str(max_range)
                final.append(new_line)


with open("output.txt", "w") as f:
    for item in final:
        f.write("%s\n" % item)

函数的作用是：在有空格的行中打断字符串，并以字符串列表的形式返回结果。查看文档，我认为这会有助于退出。这些是.bed文件，您尝试执行的操作称为交叉点

如果您使用的是linux或mac，或者您可以访问其中一个，那么您可以安装bedtools，这是值得的，因为您可以在一行代码中完成所有这一切：

bedtools intersect -wa -wb -a minor_file -b major_file > new_text_file

事实上，间隔交叉点正是开发bedtools的原因

有一个叫做“pybedtools”的python发行版，但它也只适用于mac和linux，所以我认为用python做这件事没有什么好处

当然，你可以用Python做任何事情，但是如果你要做任何数量的生物信息学，bedtools和GATK（基因组分析工具包，来自Broad Institute，仅限于命令行界面）是在shell中执行某些操作的很好的理由。此外，您需要在某个时间点对间隔进行排序，这样下游操作就可以工作，而且不会花费很长时间。因此，使用shell命令“sort”（sort-k1,1V-k2,2n-k3,3n[your_file]>[new_sorted_file]）太快了

但是GATK和bedtools中的基因组特定工具（那些需要索引基因组序列文件的工具）是在shell中执行某些操作的主要原因