嵌套循环可在Python中查找所有可能的组合

Question

Hi all I have a bioinformatics problem I could do with help on. Its quite long but I'll try break it down into smaller sections any help is wonderful.

I have a sequence of RNA length 'n' made up of 4 letters A,U,C,G that is imported as a string into Python, that can fold to make a loop. A loop is made by matching pairs of letters from the sequence so that A is with U, C is with G and G is with U so that the string folds back on itself.

The catch is that there must be three or more letters next to each other which form a pair, more than or equal to 3 letters forming a pair in a row and that there must be a gap between the sections of at least 3 letters as well.

I tried to post a picture but i don't have enough reputation points :(

In the journal I'm referencing the author talks about a nested loop method to find all possible combinations where this is possible and then containing them in a group to be called upon later.

My problem is writing the nested loops as I'm new to programming and python. As well as storing the sequences in a way where it is possible to identify the pairs and possibly add them together.

Again any help would be great and if anything is unclear please let me know

edit:

an example would be seq='aggcuugaguuu' where one of the outputs showed the pairing of seq[0:2] with seq[9:11] meaning the code forms like a U-shape.

If you imagine the string as a physical piece of string and hold it at 3 points and hold it at three different points and then touched the points together it would cause the string to form a loop. I'm looking to identify the 6 points used.

I'm not looking for code to be written for me I'd just like to know a method for composing the code.

I tried a method where seq1=input code and seq2=reverse input code and moved seq2 along seq1 looking for three neighbouring pairs but this didn't give me the correct output.

Answer 1

Have you considered using product from itertools . Then you can iterate over result and choose only these results, that you like.

Answer 2

If your RNA isn't terribly long (a thousand of bases probably OK; hundreds of thousands definitely not OK), you can get away with a simple O(n^3) algorithm. O(n^3) means that the execution time is, at worst, proportional to the cube of the number of bases. The author mentioning nested loops hints heavily toward this simple but rather slow method.

def find_loops(rna, min_pairs=3, min_loop=3):
    n = len(rna)
    result = []
    for loop_start in xrange(min_pairs, n - min_pairs - min_loop + 1):
        for loop_end in xrange(loop_start + min_loop, n - min_pairs):
            if (loop_end - loop_start < min_loop + 2 or 
                    not base_pair(rna[loop_start], rna[loop_end - 1])):
                max_pairs = min(loop_start, n - loop_end)
                for k in xrange(max_pairs):
                    if not base_pair(rna[loop_start - k - 1], rna[loop_end + k]):
                        break
                else:
                    k = max_pairs
                if k >= min_pairs:
                    result.append((loop_start - k, k, loop_end - loop_start))
    return result

def base_pair(x, y):
    return (x == 'A' and y == 'U' or
            x == 'C' and y == 'G' or
            x == 'G' and y == 'C' or
            x == 'U' and y == 'A')

This iterates over all possible beginnings and ends of the RNA loop, and then walks away from the ends of the potential loop, in both directions, as long as the bases still pair. When it reaches a pair of mismatched bases, it stops and checks that it's got at least the minimum number of pairs. If it has, it adds the loop to the list of results.

The first if is there to avoid listing loops that could be "zipped" even tighter. As the condition reads, a loop can not be zipped tighter if it's either too short (less than five bases), or its ends do not match.

The result is a list of tuples, one for each possible loop, of the form (start_pos, pair_count, loop_length) . That means that a sequence of pair_count bases, starting from base number start_pos , is followed by a loop of loop_length bases, followed by the complementary sequence in reverse. The antisense copy of the sequence starts at base start_pos + pair_count + loop_length . First base is number 0, not 1 (we're programmers here).

An example might make this clearer: print find_loops('GGGGAUUACAGCGUGUAAUCAAUA') returns [(4, 3, 13), (3, 7, 3)] , that is, it finds two loops:

• At position 4, three bases, AUU , enclose a loop of 13 bases, and bind to the AAU at position 20;
• At position 3, seven bases, GAUUACA , enclose a loop of three bases, and bind to the UGUAAUC at position 13.

Without the first if , the function would also return loops like (3, 6, 5) (ie GAUUAC at position 3 encloses a loop of five bases and binds to the GUAAUC at position 14), which is the same loop as (3, 7, 3) above, only not zipped as tightly as it would go.

Hope this helps. If you need a faster algorithm, I'm sure there's a dynamic programming solution that works with longer strings. Let me know and I'll think about it. It won't be nearly as easy to understand, though...