Question

如果n是3，那么序列＆＃34; ATATATATAG＆＃34;包含4x＆＃34; ATA＆＃34;，3x＆＃34; TAT＆＃34;和1x＆＃34; TAG＆＃34;。因此比例为4/8 = 0.5。这个数字越高，序列重复得越多。

编写一个函数simple(s,n)，其中s是一个序列，n是要考虑的k-mer的长度。该函数应返回上述比例。

有人可以帮帮我吗？

Answer 1

from nltk import ngrams
from collections import Counter


def simple(seq, n):
    return Counter(ngrams(seq, n)).most_common(1)[0][1] / float(len(seq) - n + 1)

Answer 2

这看起来像是家庭作业，但至少它是脑筋急转弯的类型。

提示：itertools，generators和collections对于这类问题非常方便。

import itertools
import collections

ACIDS = ('A', 'C', 'T', 'G')


def walk_seq(s, chunk_size):
    assert len(s) >= chunk_size
    for i in range(0, len(s) - chunk_size + 1):
        yield s[i:i+chunk_size]


def simple(s, n):
    snip_counts = collections.defaultdict(int)
    for chunk in walk_seq(s, n):
        for snip_tuple in itertools.product(ACIDS, repeat=n):
            snip = ''.join(snip_tuple)
            if chunk == snip:
                snip_counts[snip] += 1
    total_matches = sum(snip_counts.values())
    maxi = max(snip_counts.values())
    return float(maxi) / total_matches

print simple('ATATATATAG', 3)

Answer 3

这是一个非常好的算法问题，也可以自己尝试，但这里的解决方案几乎没有什么挑战。

s = "ATATATATAG"
n = 3

def simple(s,n):
    dictionary = {}
    total = 0
    for i in range (len(s)-(n-1)): # (n-1) to get last element
        k = i+n
        if s[i:k] in dictionary:
            dictionary[s[i:k]] += 1
        else:
            dictionary.update({s[i:k]:1})
        total += 1 # doing it here to avoid sum(dictionary.values())

    for key, value in dictionary.items():
        dictionary[key] = value/total
    # As a challenge, edit the line above to lambda function
    print(dictionary)

simple(s,n)

# sample output
#{'TAT': 0.375, 'ATA': 0.5, 'TAG': 0.125}

计算最大k-mer重复频率

3 个答案: