summarizing 2 text files in python [closed]

These are .bed files and what you’re trying to do is called an intersection.

If you're on a linux or mac, or if you have access to one, you could install bedtools, which is worth it because you can do all of this in one line of code:

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

In fact, interval intersections is exactly why bedtools was developed.

There is a python distribution of bedtools called 'pybedtools', but it's also only available for mac and linux, so I don’t think there’s much advantage to doing this in Python.

You could of course do everything in Python, but if you’re going to be doing any amount of bioinformatics, bedtools and GATK (genome analysis tool kit, from the Broad Institute, command-line interface only) are good reasons to do some things in shell. Also, you’ll need to sort your intervals at some point, so downstream manipulations work and don’t take forever. For that, it’s just all too quick to use the shell command ‘sort’ (sort -k1,1V -k2,2n -k3,3n [your_file] > [new_sorted_file]).

But GATK and the genome-specific tools (those requiring an indexed genome sequence file) in bedtools are the big reasons to do some things in shell. Similar to the bedtools intersect command, implementing that functionality in Python would require writing and debugging many lines of code, and the code would run a lot slower than just calling the appropriate command in bedtools and GATK.

I am not sure I completely got what you were aiming for with the code, so I might have changed a few things you will have to change back, but this should help - the following piece of code outputs the desired output.

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)

You were iterating on the lines and comparing lines to each other-

m in major:

The split() function break the string of the line where there are white spaces, and returns the result in a list of strings. Check out the documentation for str.split, I think that would help quit a bit.

Hi elly From what I understand of your logic I think the code below should get you off to on the right direction hope this helps.

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))