小编Ian*_*des的帖子

我几乎让我的needleman-wunsch实现工作,但我对如何处理特定情况下的追溯感到困惑.

我们的想法是,为了重新构建序列(最长路径),我们重新计算以确定得分来自的矩阵.我遇到问题的边缘情况是右下方得分不在匹配矩阵中,但是在插入列矩阵中(意味着得到的跟踪序列应该有插入).

这些序列以a2m格式记录,其中序列中的插入被记录为小写字符.所以在最终输出中ZZ,AAAC应该是对齐AAac.当我用手追溯时,我最终会AAAc因为我只访问Ic矩阵一次.这是我的白板图片.如你所见,我有三个黑色箭头和一个绿色箭头,这就是我追溯给我的原因AAAc.我应该计算第一个单元格,然后停在1,1位置？我不确定如何改变我实现这一点的方式.

注意,这里使用的替换矩阵是BLOSUM62.复发关系是

M(i,j) = max(Ic(i-1,j-1)+subst, M(i-1,j-1)+subst, Ir(i-1,j-1)+subst)
Ic(i,j) = max(Ic(i,j-1)-extend, M(i,j-1)-open, Ir(i,j-1)-double)
Ir(i,j) = max(Ic(i-1,j)-double, M(i-1,j)-open, Ir(i-1,j)-extend)

编辑:这是traceback_col_seq函数重写为更清洁.请注意,score_cell现在返回thisM,thisC,thisR而不是其中的最大值.这个版本将对齐评为AaAc,仍然存在同样的问题,现在又出现了另一个问题,即为什么它会在1,2处再次进入Ic.但是这个版本更清晰.

def traceback_col_seq(self):
    i, j = self.maxI-1, self.maxJ-1
    self.traceback = list()
    matrixDict = {0:'M',1:'Ic',2:'Ir',3:'M',4:'Ic',5:'Ir',6:'M',7:'Ic',8:'Ir'}
    while i > 0 or j > 0:
        chars = self.col_seq[j-1] + self.row_seq[i-1]
        thisM, thisC, thisR = self.score_cell(i, j, chars)
        cell = thisM + thisC + thisR
        prevMatrix = matrixDict[cell.index(max(cell))]
        print(cell, prevMatrix,i,j)
        if prevMatrix == …

我glmnet在使用R中的包有问题.我正在尝试使用它现成的,并且遇到以下问题:

test <- glmnet(seq.trans,rsem.trans)

weighted.mean.default(y,weights)中的错误:'x'和'w'必须具有相同的长度

但输入大小相同:

dim(seq.trans)
# [1]    28 17763
dim(rsem.trans)
# [1]    28 17763

导致此错误的原因是什么？

我正在更广泛的管道中使用R脚本,似乎不适用于某些版本的Rscript但与其他版本一起使用.由于无法连接到X11,调用失败,这是可以理解的,因为这是在服务器上.但我在本地安装Rscript能够处理这个问题吗？

我的本地安装是版本3.0.1,而报告此问题的其他用户的版本是3.0.2.

这是一个简单的测试用例 - 首先是.R文件:

#!/usr/bin/env Rscript

capabilities()

png("abc")

dev.off()

用我的本地环境运行:

-bash-4.1$ ./test.R
    jpeg      png     tiff    tcltk      X11     aqua http/ftp  sockets 
    TRUE     TRUE     TRUE     TRUE    FALSE    FALSE     TRUE     TRUE 
  libxml     fifo   cledit    iconv      NLS  profmem    cairo 
    TRUE     TRUE    FALSE     TRUE     TRUE    FALSE     TRUE 
null device 
          1 

运行Rscript的安装其他人正在尝试使用:

    jpeg      png     tiff    tcltk      X11     aqua http/ftp  sockets 
    TRUE     TRUE    FALSE     TRUE    FALSE    FALSE     TRUE     TRUE 
  libxml     fifo   cledit    iconv      NLS  profmem    cairo 
    TRUE     TRUE    FALSE     TRUE     TRUE    FALSE     TRUE 
Error in .External2(C_X11, …

我在R中有一个相同大小的矩阵列表,我希望彼此相乘.

我正在寻找一种方法:

list$A * list$B * list$C * ...

无需手动输入(我的列表有几十个矩阵).

我正在尝试并行运行许多命令，并且需要先对输入进行一些字符串操作。我怎样才能让下面的例子工作？

find . -mindepth 1 -type d | xargs -n 1 -P 20 -i sh -c "v={}; echo $v"

当我使用它时，$v为空。为什么它没有被保存为的值{}？

我有一个示例数据集，我想按一列对其进行分组，然后根据现有列的所有值生成 4 个新列。

以下是一些示例数据：

data = {'AlignmentId': {0: u'ENSMUST00000000001.4-1',
  1: u'ENSMUST00000000001.4-1',
  2: u'ENSMUST00000000003.13-0',
  3: u'ENSMUST00000000003.13-0',
  4: u'ENSMUST00000000003.13-0'},
 'name': {0: u'NonCodingDeletion',
  1: u'NonCodingInsertion',
  2: u'CodingDeletion',
  3: u'CodingInsertion',
  4: u'NonCodingDeletion'},
 'value_CDS': {0: nan, 1: nan, 2: 1.0, 3: 1.0, 4: nan},
 'value_mRNA': {0: 21.0, 1: 26.0, 2: 1.0, 3: 1.0, 4: 2.0}}
df = pd.DataFrame.from_dict(data)

看起来像这样：

               AlignmentId                name  value_mRNA  value_CDS
0   ENSMUST00000000001.4-1   NonCodingDeletion        21.0        NaN
1   ENSMUST00000000001.4-1  NonCodingInsertion        26.0        NaN
2  ENSMUST00000000003.13-0      CodingDeletion         1.0        1.0
3  ENSMUST00000000003.13-0     CodingInsertion         1.0        1.0
4  ENSMUST00000000003.13-0 …

我正在寻找一种漂亮的pythonic方法来找到DNA序列中的开放阅读框架.我发现许多在线实现使用索引,标志和其他这样的丑陋.

我很确定可以创建正则表达式实现,但我对正则表达式不好.一般的想法是我想通过'ATG','TAG','TGA'和'TAA'分割出一串DNA序列.但是我不想在重叠区域上分裂,例如序列'ATGA'应该分成'ATG','A'.基本上在三个框架中的每个框架中从左到右.

为清晰起见编辑:如评论中所述,尽管存在(在非零帧中),但ATGATTTTGA应该将一个序列拆分为ATG,TTTTGATGA

edit2:这就是我在没有正则表达式的情况下使用list comprehension splitting链接实现的方法.我讨厌使用旗帜.

def find_orf(seq):
    length = 0
    stop = ['TAA','TGA','TAG']
    for frame in range(3):
        orfFlag, thisLen = None, 0
        splitSeq = [seq[start+frame:start+frame+3] for start in range(0,len(seq),3)]
        for codon in splitSeq:
            if codon == 'ATG':
                orfFlag = True
                thisLen += 1
            elif orfFlag and codon in stop:
                orfFlag = None
                if thisLen > length:
                    length = thisLen
            else:
                thisLen += 1
    return length

我有/VA=\d+:(\S+):ENSG/一个在if语句中使用的perl正则表达式

if ($info =~ /VA=\d+:(\S+):ENSG/){
    $gene =$1;

我试图弄清楚在python中复制这个的最佳方法是什么.现在我有

gene_re = re.compile(r'VA=\d+:(\S+):ENSG')
this_re = re.search(gene_re, info)
if this_re is not None:
    gene = info[this_re.start(0):this_re.end(0)]

这是翻译它的好方法吗？我想这是perl实际上比python更具可读性的一个领域.

请注意,编译python正则表达式是因为接下来的三行实际上在循环内.

我有一系列用于对数据进行分类的函数.每个函数都传递相同的输入.该系统的目标是能够随意放入新的分类功能,而无需进行任何调整.

为此,我使用了classes_in_module从这里取消的功能.然后,将在每个输入上运行一个python文件中的每个分类器.

但是,我发现将分类器实现为类或函数是kludgy.类意味着实例化和执行,而函数缺乏干净的内省以允许我查询名称或使用继承来定义公共值.

这是一个例子.一,类实现:

class AbstractClassifier(object):
    @property
    def name(self):
        return self.__class__.__name__

class ClassifierA(AbstractClassifier):
    def __init__(self, data):
        self.data = data
    def run(self):
        return 1

然后可以以这种方式使用它,假设它classifier_list是classes_in_module包含ClassifierA在其他文件中的文件的输出:

result = []
for classifier in classifier_list:
    c = classifier(data)
    result.append(c.run())

然而,这似乎有点傻.这个类显然是静态的,并不需要维护自己的状态,因为它被使用一次并被丢弃.分类器实际上是一个函数,但是我失去了拥有共享name属性的能力- 我将不得不使用丑陋的内省技术sys._getframe().f_code.co_name并为每个分类器函数复制该代码.分类器之间的任何其他共享属性也将丢失.

你怎么看？我应该接受这种错误使用课程吗？或者,还有更好的方法？

这是一个例子：

extern crate clap;
use clap::{Arg, App};

fn main() {
let args = App::new("test")
    .arg(Arg::with_name("scoring_method")
            .short("s")
            .long("scoring-method")
            .help("Very very very very very very long long long long long help help help help help message message message message message message message"))
    .get_matches();
}

导致帮助文本格式如下：

（在代码模式下粘贴会导致 Stack Overflow 修复格式问题）

生成的确切字符串是：

extern crate clap;
use clap::{Arg, App};

fn main() {
let args = App::new("test")
    .arg(Arg::with_name("scoring_method")
            .short("s")
            .long("scoring-method")
            .help("Very very very very very very long long long long long help help help help help …