Question

请再次需要帮助。

我有一个名为vf_to_cluster.txt的文件，如下所示：

从中我创建了一个名为vf_accession_to_cluster_groups的词典，其中键为vf_accession（AI0 ...），值为群集组列表（['1','2','3'...]）。
我已经通过这种方式编写了这个（我知道这不是一个漂亮的代码，而是我现在可以做的事情，我知道对不起）：

f = 'script_folder/vf_to_cluster.txt'
vf_accession_to_cluster_groups = {}

with open(f, 'r') as f6:
    for lines in f6.readlines():
        lines = lines.replace('[', '')
        lines = lines.replace(']', '')
        lines = lines.replace(',', '')
        lines_split = lines.strip().split(' ')
        vf_keys = lines_split[0]
        cluster_values = lines_split[1:]
        vf_accession_to_cluster_groups[vf_keys] = cluster_values

获取此词典后，我的主要目标是查看有多少vf_accessions（AI0 ...）共享相同的群集组。所以我可以说，例如AI001和AI002共享4个簇组，意味着那两个vf_accession可能相同或非常接近（由相同的基因编码）。
我做了这个代码：

for vf_1 in vf_accession_to_cluster_groups.keys():
    print '-'*40
    for vf_2 in (vf_accession_to_cluster_groups.keys():
        res = 0 
        if vf_1 != vf_2:
            for i in vf_accession_to_cluster_groups[vf_1]:
                for j in vf_accession_to_cluster_groups[vf_2]:
                    if i == j : 
                        res = res + 1

            print vf_1, vf_2, res

我得到了类似的东西：

我设法丢弃比较：AI001 AI001或AI002 AI002 ...
使用if vf_1 != vf_2：

但是我不能不允许这样的比较： AI014 AI015然后，我的代码以另一种方式比较AI015 AI014 基本上，我想要的是放弃那种比较。如果比较一次，不要再以另一种方式比较它。有人可以帮帮我吗？

此外，如果任何生物信息学家看到我的矩阵，你认为我应该将群集列表的大小包括在我的vf_accession比较中，如：

dist = float(res) / len(set(vf_accession_to_cluster_groups[vf_1] + vf_accession_to_cluster_groups[vf_2]))

感谢大家提供的任何帮助。

Answer 1

如果您没有数百万个密钥，您可以将密钥存储在列表中并对其进行排序（使结果具有人工可读性）。

cluster_groups = list(vf_accession_to_cluster_groups.keys())
cluster_groups.sort()

现在，您可以使用enumerate循环覆盖所有密钥（最后一个密钥除外，因为您不需要将其与自身进行比较）：

for index, vf_1 in enumerate(cluster_groups[:-1]):

并且在你刚刚用于外循环的那个键之后的所有键上进行比较循环

    for vf_2 in cluster_groups[index + 1:]:

完整代码

cluster_groups = list(vf_accession_to_cluster_groups.keys())
cluster_groups.sort()

for index, vf_1 in enumerate(cluster_groups[:-1]):
    print('-'*40)
    for vf_2 in cluster_groups[index + 1:]:
        res = 0 
        for i in vf_accession_to_cluster_groups[vf_1]:
            for j in vf_accession_to_cluster_groups[vf_2]:
                if i == j : 
                    res = res + 1

        print(vf_1, vf_2, res)

一些小建议

将结果存储在字典中，以便稍后检索。你可以使用字典词典。
如果您想检查项目是否在列表中，请使用

if item in my_list:

更新了代码

cluster_groups = list(vf_accession_to_cluster_groups.keys())
cluster_groups.sort()

results = dict()

for index, vf_1 in enumerate(cluster_groups[:-1]):
    print('-'*40)
    results[vf_1] = dict()
    for vf_2 in cluster_groups[index + 1:]:
        res = 0 
        for i in vf_accession_to_cluster_groups[vf_1]:
            if i in vf_accession_to_cluster_groups[vf_2]:
                res = res + 1

        print(vf_1, vf_2, res)
        results[vf_1].update({vf_2: res})


def get_results(key1, key2, results):
    if key1 > key2:
        key1, key2 = key2, key1

    if results.get(key1):
        return results[key1].get(key2)
    return None

Answer 2

您可以使用itertools.combinations只获得一对。

在以下代码中，我定义了一个Accession类来表示文件行中包含的信息：入藏ID（key属性）和集群（clusters属性）。群集存储为集合，这使得计算两个种群之间共同的群集数量变得容易。这是在nb_common方法中实现的，只需获取两个集合之间的交集（&）的长度。由于Accession方法中存在的代码，从文件中的每一行创建__init__。加入列表将传递给combinations函数，2作为第二个参数，因为我们需要成对的加入。我们在结果对上循环，并使用nb_common方法获取当前对的两个访问之间的公共簇数。

在这里，我还使用sys.argv[1]将文件作为命令行的第一个参数。

#!/usr/bin/env python

import sys
from itertools import combinations

class Accession(object):
    """This represents an accession and the corresponding clusters."""
    def __init__(self, line):
        line_parts = line.strip().split(" ")
        self.key = line_parts[0]
        # "".join(...) re-creates a string representing the list of clusters
        # [1:-1] eliminates the brackets
        self.clusters = set("".join(line_parts[1:])[1:-1].split(","))

    def nb_common(self, other):
        return len(self.clusters & other.clusters)

with open(sys.argv[1], "r") as cluster_file:
    accessions = [Accession(line) for line in cluster_file]

for (acc1, acc2) in combinations(accessions, 2):
    print acc1.key, acc2.key, acc1.nb_common(acc2)

我按如下方式调用脚本：

$ ./compare_accessions.py vf_to_cluster.txt 
AI001 AI002 4
AI001 AI004 4
AI001 AI005 4
AI001 AI010 0
AI001 AI011 0
AI001 AI012 4
AI001 AI013 0
AI001 AI014 0
AI001 AI015 5
AI001 AI016 0
AI001 AI017 0
AI002 AI004 4
AI002 AI005 4
AI002 AI010 0
AI002 AI011 0
AI002 AI012 4
AI002 AI013 0
AI002 AI014 0
AI002 AI015 4
AI002 AI016 0
AI002 AI017 0
AI004 AI005 4
AI004 AI010 0
AI004 AI011 0
AI004 AI012 4
AI004 AI013 0
AI004 AI014 0
AI004 AI015 5
AI004 AI016 0
AI004 AI017 0
AI005 AI010 0
AI005 AI011 0
AI005 AI012 4
AI005 AI013 0
AI005 AI014 0
AI005 AI015 4
AI005 AI016 0
AI005 AI017 0
AI010 AI011 0
AI010 AI012 0
AI010 AI013 0
AI010 AI014 1
AI010 AI015 1
AI010 AI016 0
AI010 AI017 0
AI011 AI012 0
AI011 AI013 1
AI011 AI014 0
AI011 AI015 1
AI011 AI016 0
AI011 AI017 0
AI012 AI013 0
AI012 AI014 0
AI012 AI015 4
AI012 AI016 0
AI012 AI017 0
AI013 AI014 0
AI013 AI015 1
AI013 AI016 0
AI013 AI017 0
AI014 AI015 1
AI014 AI016 0
AI014 AI017 0
AI015 AI016 1
AI015 AI017 0
AI016 AI017 0

如何将常见群集的数量转换为距离似乎是一个非常开放的问题。你可以在bioinformatics stackexchange site中提出这个问题，不要忘记介绍你的生物学问题。

将字典与自身进行比较，但如果已经比较则避免两次比较

2 个答案: