天道酬勤,学无止境

Python:多个共识序列(Python: Multiple Consensus sequences)

问题

从 dna 序列列表开始,我必须返回所有可能的共有序列(在每个位置具有最高核苷酸频率的结果序列)序列。 如果在某些位置核苷酸具有相同的最高频率,我必须以最高频率获得所有可能的组合。 作为回报,我还必须有轮廓矩阵(一个矩阵,其中包含每个序列的每个核苷酸的频率)。

到目前为止,这是我的代码(但它只返回一个共识序列):

seqList = ['TTCAAGCT','TGGCAACT','TTGGATCT','TAGCAACC','TTGGAACT','ATGCCATT','ATGGCACT']
n = len(seqList[0])
profile = { 'T':[0]*n,'G':[0]*n ,'C':[0]*n,'A':[0]*n }

for seq in seqList:

    for i, char in enumerate(seq):
        profile[char][i] += 1



consensus = ""
for i in range(n):
    max_count = 0
    max_nt = 'x'
    for nt in "ACGT":
        if profile[nt][i] > max_count:
            max_count = profile[nt][i]
            max_nt = nt
    consensus += max_nt
print(consensus)
for key, value in profile.items():
     print(key,':', " ".join([str(x) for x in value] ))

TTGCAACT
C : 0 0 1 3 2 0 6 1
A : 2 1 0 1 5 5 0 0
G : 0 1 6 3 0 1 0 0
T : 5 5 0 0 0 1 1 6

(如你所见,在位置四,C和G的最高分相同,这意味着我必须获得两个共识序列)

是否可以修改此代码以获得所有可能的序列,或者您能否向我解释如何获得正确结果的逻辑(伪代码)?

非常感谢您提前!

回答1

我相信有更好的方法,但这是一个简单的方法:

bestseqs = [[]]
for i in range(n):
    d = {N:profile[N][i] for N in ['T','G','C','A']}
    m = max(d.values())
    l = [N for N in ['T','G','C','A'] if d[N] == m]
    bestseqs = [ s+[N] for N in l for s in bestseqs ]

for s in bestseqs:
    print(''.join(s))

# output:
ATGGAACT
ATGCAACT

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • Python: Multiple Consensus sequences
    starting from a list of dna sequences, I must have in return all the possible consensus (the resulting sequence with the highest nucleotide frequency in each position) sequences. If in some positions the nucleotides have the same highest frequency, I must obtain all possible combinations with the highest frequency. I also must have in return the profile matrix ( a matrix with the frequencies of each nucleotide for each sequence). This is my code so far (but it returns only one consensus sequence): seqList = ['TTCAAGCT','TGGCAACT','TTGGATCT','TAGCAACC','TTGGAACT','ATGCCATT','ATGGCACT'] n = len
  • Paxos、Raft不是一致性算法/协议?
    作为互联网中的一员,我们时常沉浸在“分布式”的氛围当中——高可用、高可靠、高性能等等词汇随处可见,CAP、BASE、2PC、Paxos、Raft等等名词也能信手捏来。不过,有些词在我们“并不严谨”的传播中逐渐被误用了,或者说含糊不清了。今天,我们来简单聊聊“Consistency”这个词,即一致性。Paxos、Raft等通常被误称为“一致性算法”。但是“一致性(Consistency)”和“共识(Consensus)”并不是同一个概念。Paxos、Raft等其实都是共识(Consensus)算法。Leslie Lamport于1998年在ACM Transactions on Computer Systems上发表了一篇《The Part-Time Parliament》[1]的文章,这是Paxos算法第一次公开发表。但是发表之后,很多人还是觉得原来那篇太难理解了,之后Lamport又写了一篇《Paxos Made Simple》[2],当我们想要学习一下Paxos的时候,可以直接看看这篇。回到正题,我们在《Paxos Made Simple》中搜索“Consistency”一词,如下图所示,其实是毫无匹配结果的。反观,我们搜索“Consensus”一词的时候,却出现了很多匹配项。也就是说,Paxos论文通篇提都没提Consistency一词,何来的“Paxos is a
  • 当您不知道序列长度时,在Python中进行多次拆箱分配(Multiple Unpacking Assignment in Python when you don't know the sequence length)
    问题 多个拆箱作业的教科书示例如下: import numpy as NP M = NP.arange(5) a, b, c, d, e = M # so of course, a = 0, b = 1, etc. M = NP.arange(20).reshape(5, 4) # numpy 5x4 array a, b, c, d, e = M # here, a = M[0,:], b = M[1,:], etc. (ie, a single row of M is assigned each to a through e) (我的问题不是特定于numpy 。的确,我更喜欢纯Python解决方案。) 对于我现在正在查看的这段代码,在这种简单的场景中我看到了两个复杂的问题: 我通常不知道M的形状; 和我想解压一定数量的项目(肯定少于所有项目),我想把剩余成一个单一的容器 回到上面的5x4数组,我非常想做的是分别将M的前三行分别分配给a,b和c(与上面完全一样),其余的行(我不知道如何单个容器all_the_rest = []会有很多,只是一些正整数)。 回答1 Python 3.x可以轻松做到这一点: a, b, *c = someseq Python 2.x需要做更多的工作: (a, b), c = someseq[:2], someseq[2:] 回答2
  • 在 R 中获得多种分区方法的共识(get consensus of multiple partitioning methods in R)
    问题 我的数据: data=cbind(c(1,1,2,1,1,3),c(1,1,2,1,1,1),c(2,2,1,2,1,2)) colnames(data)=paste("item",1:3) rownames(data)=paste("method",1:6) 我希望作为输出,根据多数票,有两个社区(及其元素)。 类似于: group1={item1, item2} , group2={item3} 。 回答1 你可以试试这个,基础R : res=apply(data,2,function(u) as.numeric(names(sort(table(u), decreasing=T))[1])) setNames(lapply(unique(res), function(u) names(res)[res==u]), unique(res)) #$`1` #[1] "item 1" "item 2" #$`2` #[1] "item 3" 回答2 这个函数被传递一个矩阵,其中每一列是一个项目,每一行是一个隶属向量,对应于根据聚类方法的项目的分区。 组成每一行的元素(数字)除了表示成员资格外没有任何意义,并且会从一行到另一行循环使用。 该函数返回多数投票分区。 当某项不存在共识时,第一行给出的分区获胜。 例如,这允许通过降低模块化值来对分区进行排序。 consensus
  • python序列的解包
    序列解包 今天简记一个关于序列的小知识——序列解包 (当然,解包这一概念不仅仅可用于序列,只要对象是可迭代的,就可以解包操作) 首先先来简介一下什么是序列,序,即为顺序,列,多个元素组成的一个集合。序列就是一个有顺序的集合。比如字符串,列表,元组等可通过下标找到其对应元素的集合(注:此处的集合只是对多个元素的组成的一个引用名,并非python中的set) okk,我们通过一个小问题来引入我们这个序列解包。 题:如何将一个包含多个元素的序列中的元素赋值给多个变量? # 先定义一个序列 a = 1,2,3,4,5 # 引入序列解包这个概念,用多个变量来接收序列a中的元素 s,d,f,g,h = a # 输出变量查看结果 print(s,d,f,g,h) 1 2 3 4 5 # 乱序输出 print(h,s,g,d,f) 5 1 4 2 3 可,通过这个小题我们已经可以大致了解序列解包怎么使用了。但是需要注意一点,用来接收序列的变量必须与序列元素数目保持一致,否则会报错 >>> a = 1,2,3,4,5 >>> s,d,f = a Traceback (most recent call last): File "<pyshell#26>", line 1, in <module> s,d,f = a ValueError: too many values to unpack
  • From blockchain consensus back to Byzantine consensus
    文章目录 1. Pow model2. 一般化的共识问题——拜占庭共识3. 区块链共识算法3.1 有向无环图(DAG: Directed acyclic graph)3.2 分叉(Forks)3.3 主链选择(main branch selection)3.4 区块的决定和交易的确认(Decided blocks and committed transactions) 4. Pow区块链的风险5. 区块链拜占庭共识6. 联盟链(blockchain model for consortiums) The novelty of blockchain is a genuine combination of wellknown research results taken from distributed computing, cryptography and game theory. Its distributed nature guarantees the persistence of the ledger data. Its public key crypto-system offers the capabilities for a user to sign transactions that transfer assets from her account to other
  • 下标序列时,Python中的::(双冒号)是什么?(What is :: (double colon) in Python when subscripting sequences?)
    问题 我知道我可以使用string[3:4]类的东西来获取Python中的子字符串,但是3在somesequence[::3]是什么意思somesequence[::3] ? 回答1 它的意思是“第一个参数不加任何内容,第二个参数不加任何内容,然后跳三”。 它获取序列中每隔三分之一的内容。 扩展片就是您想要的。 Python 2.3的新功能 回答2 可以将Python序列切片地址写为[start:end:step],并且可以删除开始,停止或结束中的任何一个。 a[::3]是序列的每三个元素。 回答3 seq[::n]是整个序列中每个第n个项目的序列。 例子: >>> range(10)[::2] [0, 2, 4, 6, 8] 语法为: seq[start:end:step] 因此,您可以执行以下操作(在Python 2中): >>> range(100)[5:18:2] [5, 7, 9, 11, 13, 15, 17] 回答4 解释 根据文档, s[i:j:k]为“从步骤i到j的s切片”。 当i和j不存在时,将假定整个序列,因此s[::k]表示“第k个项目”。 例子 首先,让我们初始化一个列表: >>> s = range(20) >>> s [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
  • Python-基础-常用术语对照表
    ***下面内容主要摘抄自python 官网,https://docs.python.org/3.7/glossary.html#glossary,部分内容有删减。 2to3 一个将 Python 2.x 代码转换为 Python 3.x 代码的工具,能够处理大部分通过解析源码并遍历解析树可检测到的不兼容问题。 2to3 包含在标准库中,模块名为 lib2to3;并提供一个独立入口点 Tools/scripts/2to3。参见 2to3 - 自动将 Python 2 代码转为 Python 3 代码。 因为官方将在2020年不再支持 Python 2.x, 在遇到没有Python 2.X 版本 的code 的时候,可以尝试使用这个工具将代码转化成Python 的版本。 abstract base class -- 抽象基类 抽象基类简称 ABC,是对 duck-typing 的补充,它提供了一种定义接口的新方式,相比之下其他技巧例如 hasattr() 显得过于笨拙或有微妙错误(例如使用 魔术方法)。ABC 引入了虚拟子类,这种类并非继承自其他类,但却仍能被 isinstance() 和 issubclass() 所认可;详见 abc 模块文档。Python 自带许多内置的 ABC 用于实现数据结构(在 collections.abc 模块中)、数字(在 numbers 模块中)、流
  • 用str方法替换字符串中的多个元素(Replace multiple elements in string with str methods)
    问题 我正在尝试编写一个函数,该函数需要一串DNA并返回赞美。 我已经尝试解决了一段时间,并仔细阅读了Python文档,但无法解决。 我已经为该函数编写了文档字符串,因此您可以看到答案应该是什么样子。 我在该论坛上看到过类似的问题,但我无法理解答案。 如果有人可以仅使用str格式和循环/ if语句来解释这一点,我将不胜感激,因为我尚未详细研究字典/列表。 我尝试了str.replace但无法使它适用于多个元素,尝试嵌套if语句,但这也不起作用。 然后,我尝试编写4个单独的for循环,但无济于事。 def get_complementary_sequence(dna): """ (str) -> str Return the DNA sequence that is complementary to the given DNA sequence. >>> get_complementary_sequence('AT') TA >>> get_complementary_sequence('GCTTAA') CGAATT """ for char in dna: if char == A: dna = dna.replace('A', 'T') elif char == T: dna = dna.replace('T', 'A') # ...and so on 回答1
  • 如何将bash别名定义为多个命令的序列? [复制](How can I define a bash alias as a sequence of multiple commands? [duplicate])
    问题 这个问题已经在这里有了答案: bash别名中的多个命令(9个答案) 2年前关闭。 我知道如何在bash中配置别名,但是有没有办法为一系列命令配置别名? 即说我希望一个命令更改为特定目录,然后运行另一个命令。 另外,是否可以设置运行“ sudo mycommand”然后输入密码的命令? 在MS-DOS时代,我会寻找一个.bat文件,但是我不确定Linux(或Mac OSX)是否等效。 回答1 您提到了BAT文件,所以也许您想要的是编写Shell脚本。 如果是这样,则只需将要逐行输入的命令输入到文件中,如下所示: command1 command2 并要求bash执行文件: bash myscript.sh 如果您希望能够直接调用脚本而无需键入“ bash”,则将以下行添加为文件的第一行: #! /bin/bash command1 command2 然后将文件标记为可执行文件: chmod 755 myscript.sh 现在,您可以像运行其他任何可执行文件一样运行它: ./myscript.sh 请注意,unix并不真正在乎文件扩展名。 您可以根据需要简单地将文件命名为“ myscript”,而不以“ .sh”扩展名命名。 重要的是特殊的第一行。 例如,如果要使用Perl编程语言而不是bash编写脚本,则第一行应为: #! /usr/bin/perl 第一行告诉您的外壳
  • 如何注释多个返回值的类型?(How to annotate types of multiple return values?)
    问题 如何使用类型提示来注释一个返回Iterable的函数,该函数始终产生两个值: bool和str ? 提示Tuple[bool, str]是关闭的,除了它将返回值类型限制为一个元组,而不是生成器或其他可迭代类型。 我主要是好奇的,因为我想注释一个用于返回多个值的函数foo() ,如下所示: always_a_bool, always_a_str = foo() 通常,像foo()这样的函数会执行类似return a, b (返回一个元组)的操作,但是我希望类型提示足够灵活,可以用生成器或列表或其他东西来替换返回的元组。 回答1 您总是在返回一个对象。 使用return one, two简单地返回一个元组。 是的, -> Tuple[bool, str]是完全正确的。 只有Tuple类型允许您指定固定数量的元素,每个元素都有不同的类型。 如果您的函数产生固定数量的返回值,尤其是当这些值是特定的,不同的类型时,确实应该总是返回一个元组。 期望其他序列类型具有可变数量元素的一种类型规范,因此typing.Sequence 。 typing.Sequence在此处不适用。 另请参阅列表和元组之间的区别是什么? 元组是异构数据结构(即,它们的条目具有不同的含义),而列表是同类序列。 元组具有结构,列表具有顺序。 Python的类型提示系统遵循这种哲­
  • Python - 查找相同字符的序列(Python - Find sequence of same characters)
    问题 我正在尝试使用正则表达式来匹配字符串中相同字符的一个或多个实例的序列。 例子 : string = "55544355" # The regex should retrieve sequences "555", "44", "3", "55" 我可以给一些提示吗? 回答1 您可以使用 re.findall() 和((.)\2*)正则表达式: >>> [item[0] for item in re.findall(r"((.)\2*)", string)] ['555', '44', '3', '55'] 关键部分在外部捕获组内 - (.)\2* 。 在这里,我们通过(.)捕获单个字符,然后通过组号引用该字符: \2 。 组号为 2,因为我们有一个编号为 1 的外部捕获组。 *表示 0 次或多次。 您也可以使用单个捕获组和 re.finditer() 解决它: >>> [item.group(0) for item in re.finditer(r"(.)\1*", string)] ['555', '44', '3', '55'] 回答2 您可以使用 itertools.groupby 在没有正则表达式的情况下轻松完成此操作: >>> from itertools import groupby >>> s = '55544355' >>> [''.join(g) for _
  • Python可以测试列表中多个值的成员资格吗?(Can Python test the membership of multiple values in a list?)
    问题 我想测试列表中是否有两个或多个值具有成员身份,但结果却出乎意料: >>> 'a','b' in ['b', 'a', 'foo', 'bar'] ('a', True) 那么,Python可以一次在列表中测试多个值的成员资格吗? 结果是什么意思? 回答1 这可以满足您的需求,并且几乎可以在所有情况下使用: >>> all(x in ['b', 'a', 'foo', 'bar'] for x in ['a', 'b']) True 'a','b' in ['b', 'a', 'foo', 'bar']中的表达式'a','b' in ['b', 'a', 'foo', 'bar']无法正常工作,因为Python将其解释为元组: >>> 'a', 'b' ('a', 'b') >>> 'a', 5 + 2 ('a', 7) >>> 'a', 'x' in 'xerxes' ('a', True) 其他选择 还有其他执行此测试的方法,但是它们不适用于许多不同种类的输入。 正如Kabie指出的那样,您可以使用集合解决此问题... >>> set(['a', 'b']).issubset(set(['a', 'b', 'foo', 'bar'])) True >>> {'a', 'b'} <= {'a', 'b', 'foo', 'bar'} True ...有时: >>> {'a'
  • Python:TypeError:* 之后的参数必须是一个序列(Python: TypeError: argument after * must be a sequence)
    问题 我有这段代码,我尝试在新线程中发送 UDP 数据报 import threading, socket address = ("localhost", 9999) def send(sock): sock.sendto("Message", address) print "sent" s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) threading.Thread(target=send, args=(s)).start() 但是当我尝试将套接字作为函数的参数时,会抛出 TypeError 异常: Exception in thread Thread-1: Traceback (most recent call last): File "/usr/lib/python2.7/threading.py", line 810, in __bootstrap_inner self.run() File "/usr/lib/python2.7/threading.py", line 763, in self.__target(*self.__args, **self.__kwargs) TypeError: send() argument after * must be a sequence, not _socketobject
  • 检测序列参数的正确方法?(Correct way to detect sequence parameter?)
    问题 我想编写一个接受参数的函数,该参数可以是序列或单个值。 值的类型为str,int等,但我不希望它局限于硬编码列表。 换句话说,我想知道参数X是一个序列还是必须转换为序列的对象,以避免以后出现特殊情况。 我可以 type(X) in (list, tuple) 但是可能还有我不知道的其他序列类型,也没有通用的基类。 -N。 编辑:请参阅下面的“答案”,了解其中大多数答案对我没有帮助的原因。 也许您有更好的建议。 回答1 上述所有方法的问题在于,str被视为一个序列(可迭代,具有getitem等),但通常被视为单个项目。 例如,一个函数可以接受一个参数,该参数可以是文件名或文件名列表。 函数从后一个检测第一个的最Pythonic方法是什么? 根据修订后的问题,听起来您想要的是更多类似的东西: def to_sequence(arg): ''' determine whether an arg should be treated as a "unit" or a "sequence" if it's a unit, return a 1-tuple with the arg ''' def _multiple(x): return hasattr(x,"__iter__") if _multiple(arg): return arg else: return (arg,) >>>
  • 使用Python输入模块指定序列或列表的长度(Specify length of Sequence or List with Python typing module)
    问题 我正在给Python typing模块一个镜头。 我知道指定List的长度是有效的,例如以下*: List[float, float, float] # List of 3 floats <-- NOTE: this is not valid Python 较长的清单有速记吗? 如果我想将其设置为10个浮点数怎么办? List[float * 10] # This doesn't work. 任何想法,如果可能的话,这将很方便。 *注意:事实证明,以这种方式向Sequence[] (及其子类)提供多个参数目前不是有效的Python。 此外,当前无法以这种方式使用typing模块指定Sequence长度。 回答1 你不能列表是可变的,可变长度的结构。 如果需要固定长度的结构,请改用元组: Tuple[float, float, float, float, float, float, float, float, float, float] 或更妙的是,使用具有索引和命名属性的命名元组: class BunchOfFloats(NamedTuple): foo: float bar: float baz: float spam: float ham: float eggs: float monty: float python: float idle: float cleese
  • 使用python向组中的每个元素添加序列号(Add a sequence number to each element in a group using python)
    问题 我有一个个人的数据框,每个人都有多个记录。 我想枚举python中每个人的序列记录。 本质上,我想在下表中创建“序列”列: patient date sequence 145 20Jun2009 1 145 24Jun2009 2 145 15Jul2009 3 582 09Feb2008 1 582 21Feb2008 2 987 14Mar2010 1 987 02May2010 2 987 12May2010 3 这基本上是与这里相同的问题,但是我正在使用python进行操作,无法实现sql解决方案。 我怀疑我可以使用具有可重复计数的groupby语句,但是到目前为止没有成功。 谢谢! 回答1 问题是如何对多列数据进行排序。 一个简单的技巧是将key参数用于已排序的函数。 您将根据从数组的列构建的字符串进行排序。 rows = ...# your source data def date_to_sortable_string(date): # use datetime package to convert string to sortable date. pass # Assume x[0] === patient_id and x[1] === encounter date # Sort by patient_id and date rows_sorted =
  • 区块链基础coursera学习笔记(第四周)信任基础
    课程链接:https://www.coursera.org/learn/blockchain-basics/home/week/4 本文是自己听课做的笔记,部分翻译可能有问题,望谅解。 信任基础 Trust Essentials 目录 分布式系统 Decentralized Systems 共识协议 Consensus Protocol 鲁棒性 Robustness 分叉 Forks 周测验​​​ 编程作业 Getting Started with Blockchain Ethereum 区块链基础知识:要点 Blockchain Basics: Key Takeaways 分布式系统 Decentralized Systems 在上一个模块中,我们了解了如何使用公钥加密和哈希来验证交易和区块。 本周学习目标: 1)能够定义区块链中的信任元素,安全性,验证,验证和共识。 2)讨论共识协议,一种添加新块并保护链的算法方法; 3)解释信任和主链的鲁棒性; 4)说明在处理硬分叉和软分叉等特殊情况下的信任。 分散的区块链中的信任涉及到保护、验证、验证和确保交易执行所需的资源可用。 这是通过使用特定协议保护链,验证交易和防篡改块,验证交易资源的可用性以及执行和确认交易来实现的。 信任跟踪 Trust Trail 由以下操作定义: 验证事务;验证相应的资源;收集事务; 执行事务以获取新状态
  • 使用Python找丑数
    一个正整数的因数只有1、2、3、5和它本身,那么这个数就是丑数。那么丑数从小到大的序列为 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … . 规定,1为最小的丑数。 问题:给出一个正整数n,找到第n个丑数。 方法一: 遍历所有正整数,判断其是否为丑数; 当丑数计数器count等于n时停止。 # Python3 code to find nth ugly number # This function divides a by greatest # divisible power of b def maxDivide(a,b): while a % b ==0: a = a /b return a # Function to check if a number # is ugly or not def isUgly( no ): no = maxDivide(no,5) no = maxDivide(no,3) no = maxDivide(no,2) if no ==1: return 1 return 0 #return 1 if no==1 else 0 # Function to get the nth ugly number def getNthUglyNo(n): i = 1 count =1 #ugly number count #Check
  • python 列表的实现探析
    知其然也要知其所以然,python中的容器对象真的不多,平常我们会很心安理得的根据需求来使用对应的容器,不定长数据用list,想去重用set,想快速进行匹配用dict,字符处理用str,可为何能实现这个效果呢?比如我们用list的时候,知道这玩意可以随意存储各种格式,存整型、浮点、字符串、甚至还可以嵌套list等其他容器,这底层的原理到底是用数组实现的,还是用链表?比如我们的字典,底层是用数组还是其他?如果是其他如哈希表,那又怎么实现输入数据的顺序排列?这次不妨一层层剖析,推演一番。贪多嚼不烂,本次就先对list进行分析 简述 这个名字很容易和其它语言(C++、Java等)标准库中的链表混淆,不过事实上在CPython的列表根本不是列表(这话有点绕,可能换成英文理解起来容易些:python中的list不是我们所学习的list),在CPython中,列表被实现为长度可变的数组。 从细节上看,Python中的列表是由对其它对象的引用组成的连续数组,指向这个数组的指针及其长度被保存在一个列表头结构中。这意味着,每次添加或删除一个元素时,由引用组成的数组需要该标大小(重新分配)。在实现过程中,Python在创建这些数组时采用了指数分配的方式,其结果导致每次操作不都需要改变数组的大小,但是也因为这个原因添加或取出元素的平均复杂度较低。 这个方式带来的后果是在普通链表上“代价很小