TypeError: ‘module’ object is not callable，还是本座的疏忽导致的

今天在研究BioPython教程里面的一个代码。把它写到脚本里面一运行啊，出现咯错误：

bash-4.1# python Translate1.py

Traceback (most recent call last):

  File “Translate1.py”, line 7, in <module>

    my_seq=Seq(“GATCGATGGGCCTATATAGGATCGAAAATCGC”,IUPAC.unambiguous_dna)

TypeError: ‘module’ object is not callable

上古鸽一搜索，说的大多是导入模块时写得有问题。于是本座仔细检查咯一下自己保存到脚本中的代码，果然，有一句少写了一点东西。

本座写入的脚本是：

#!/usr/bin/python

#coding:utf-8

from Bio import Seq

from Bio.Alphabet import IUPAC

my_seq=Seq(“GATCGATGGGCCTATATAGGATCGAAAATCGC”,IUPAC.unambiguous_dna)

print my_seq

而教程里面是：

#!/usr/bin/python

#coding:utf-8

from Bio.Seq import Seq

from Bio.Alphabet import IUPAC

my_seq=Seq(“GATCGATGGGCCTATATAGGATCGAAAATCGC”,IUPAC.unambiguous_dna)

print my_seq

原来是本座抄代码的时候漏咯一个“Seq”。

也就是说，my_seq实际上是一个Bio.Seq.Seq对象。

改过来之后，就好咯。

Kate dNA开发进展：使用clustalw2来完成其中的比对任务

此文章来自于Kate dNA的勃客：http://stupidbeauty.com/KNA/2011/05/kate-dna%e5%bc%80%e5%8f%91%e8%bf%9b%e5%b1%95%ef%bc%9a%e4%bd%bf%e7%94%a8clustalw2%e6%9d%a5%e5%ae%8c%e6%88%90%e5%85%b6%e4%b8%ad%e7%9a%84%e6%af%94%e5%af%b9%e4%bb%bb%e5%8a%a1/

以前是使用一个简单的算法来自己实现比对的，效果不好。在与某生物学砖家交流之后，认为应当采用专门的比对工具来进行比对，因此选择咯使用clustalw2来进行比对。在运行过程中会调用clustalw2。

来看演示。

启动程序。

刚才看到的是主界面。

下一步操作：设置要参与比对的序列的个数。在更改个数之后，会自动生成对应那么多个输入框。改成8个吧。生成8个输入框咯，其它的东西也配套生成8个咯。

下一步操作：载入各个序列。单击序列输入框右边的“载入”按钮就可以载入对应的序列。载入一个序列咯。下面载入其余的7个。好咯，载入咯8个序列。

下一步操作：单击下面的“查找”按钮，使程序进行比对，并且绘制出进化树。比对是用clustalw2进行的，进化树是用PHYLIP中的dnapars计算，使用drawgram绘制的。clustalw2运行起来比较慢。等待。比对完毕之后，会在每个序列的右边的“StartPosition”“EndPosition”组合框里填入各个“变异”位点的位置列表，供你选择在最终计算串联重复序列的时候要使用整个序列中的哪一部分来计算。哦，已经比对完咯，组合框里面也填充咯内容，可以用鼠标点击选择已有的变异位点的位置，也可以自己指定某个特定位置。对每个组合框的位点的选择，只会影响到对应的序列的串联重复序列的计算。目前在选择过程中不提供视觉反馈，等有时间咯会提供视觉反馈的。

对咯，这个时候进化树已经绘制出来咯，可以先看看进化树，把串联重复序列的事放一边。

切换到DnaPars标签页。

这是drawgram程序画的进化树，线条比较粗糙。等有时间咯会自己写代码来画一个更精细的进化树的。

继续看串联重复序列的事。

选好咯要参与串联重复序列的计算的起止位置之后，单击右下角的“Position Choosing OK”（还没来得及翻译成简体中文哈）按钮。再来一次漫长的等待。

看到状态栏咯吧？这个时候正在调用TandemRepeatsFinder和Mreps来计算串联重复序列。针对每个序列都会调用一次。所以你会看到一下子是“……完成”一下子又是“正在启动……”。这是正常的。

有结果咯。Trf视图和Mreps视图中都有8个串联重复序列图，分别对应着“Sequences”标签页中的8个序列。

完咯。

演示视频可在这里下载：http://www.filesonic.com/file/1068625494

BioPython文档翻译：MultipleSeqAlignment类，Class MultipleSeqAlignment

表示一个经典的多序列比对（MSA）。

 

这个东西表示的是一组长度相同（通常使用缺口字符来填充空缺位置）的序列（通常显示成行）。这个数据可被看成一个字母矩阵，其中有整齐的（well defined）列。

 

一般地，你可以通过使用AlignIO模块载入一个比对文件来创建一个多序列比对：

 

>>> from Bio import AlignIO

>>> align = AlignIO.read(“Clustalw/opuntia.aln”, “clustal”)

>>> print align

SingleLetterAlphabet() alignment with 7 rows and 156 columns

TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG…AGA gi|6273285|gb|AF191659.1|AF191

TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG…AGA gi|6273284|gb|AF191658.1|AF191

TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG…AGA gi|6273287|gb|AF191661.1|AF191

TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG…AGA gi|6273286|gb|AF191660.1|AF191

TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG…AGA gi|6273290|gb|AF191664.1|AF191

TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG…AGA gi|6273289|gb|AF191663.1|AF191

TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG…AGA gi|6273291|gb|AF191665.1|AF191

 

从某些方面来说，你可以将这些对象当成SeqRecord 对象的列表，其中每一个都表示咯比对中的一行。遍历一个比对的话，就得到针对每一行的SeqRecord 对象：

 

>>> len(align)

7

>>> for record in align:

…     print record.id, len(record)

gi|6273285|gb|AF191659.1|AF191 156

gi|6273284|gb|AF191658.1|AF191 156

gi|6273287|gb|AF191661.1|AF191 156

gi|6273286|gb|AF191660.1|AF191 156

gi|6273290|gb|AF191664.1|AF191 156

gi|6273289|gb|AF191663.1|AF191 156

gi|6273291|gb|AF191665.1|AF191 156

 

你还可以通过下标（index）来以 SeqRecord 对象的方式访问单独的行：

 

>>> print align[0].id

gi|6273285|gb|AF191659.1|AF191

>>> print align[-1].id

gi|6273291|gb|AF191665.1|AF191

 

还可以以字符串的方式提取列：

 

>>> print align[:,1]

AAAAAAA

 

或者，取出前10列作为一个子比对（sub-alignment）：

 

>>> print align[:,:10]

SingleLetterAlphabet() alignment with 7 rows and 10 columns

TATACATTAA gi|6273285|gb|AF191659.1|AF191

TATACATTAA gi|6273284|gb|AF191658.1|AF191

TATACATTAA gi|6273287|gb|AF191661.1|AF191

TATACATAAA gi|6273286|gb|AF191660.1|AF191

TATACATTAA gi|6273290|gb|AF191664.1|AF191

TATACATTAA gi|6273289|gb|AF191663.1|AF191

TATACATTAA gi|6273291|gb|AF191665.1|AF191

 

将这种比对切割（slicing）和比对的加法（addition）结合，就允许你删除这个比对的某个部分。比如，只取出前10列和末10列：

 

>>> print align[:,:10] + align[:,-10:]

SingleLetterAlphabet() alignment with 7 rows and 20 columns

TATACATTAAGTGTACCAGA gi|6273285|gb|AF191659.1|AF191

TATACATTAAGTGTACCAGA gi|6273284|gb|AF191658.1|AF191

TATACATTAAGTGTACCAGA gi|6273287|gb|AF191661.1|AF191

TATACATAAAGTGTACCAGA gi|6273286|gb|AF191660.1|AF191

TATACATTAAGTGTACCAGA gi|6273290|gb|AF191664.1|AF191

TATACATTAAGTATACCAGA gi|6273289|gb|AF191663.1|AF191

TATACATTAAGTGTACCAGA gi|6273291|gb|AF191665.1|AF191

 

注意-这个对象是用来取代已有的在Bio.Align.Generic 模块中定义的Alignment 对象的，但是并不是完全地后向兼容它。

 

注意-这个对象并不尝试对有多个序列读取的下一代序列中使用的那种类型的比对进行建模，它们比比对对象本身短得多，并且通常会有一个重复序列（consensus）或者带有特殊状态的引用序列。

Qt4.7.0文档翻译：QFrame类参考，QFrame Class Reference

QFrame类是那些可以带有边框的部件的基类。

Qmenu使用这个东西来使自己看起来位于周围屏幕的上方（”raise”）。QProgressBar有一个“下沉的”（”sunken”）外观。QLabel有一个平坦的（flat）外观。这些东西的边框都可以改变。

 QLabel label(…);

 label.setFrameStyle(QFrame::Panel | QFrame::Raised);

 label.setLineWidth(2);

 QProgressBar pbar(…);

 label.setFrameStyle(QFrame::NoFrame);

QFrame类还可以用来直接创建一些简单的占位边框，其中不包含任何内容。

边框的外观是用一个边框形状和阴影类型属性指定的，后者用来从视觉上将边框与周围的部件分开。这2个属性可以一起用setFrameStyle()函数来设置，用frameStyle()来读取。

可选的边框形状有NoFrame、Box、Panel、StyledPanel、HLine和VLine；可选的阴影类型有Plain、Raised和Sunken。

一个边框部件使用3个属性来描述它的边界线的宽度（thickness）：lineWidth、midLineWidth和frameWidth。

• •.线宽（line width）是边框的边界（border）的宽度。可以修改它，以改变边框的外观。 

• •.中线宽度（mid-line width）指定咯在边框中间的一条额外的线的宽度，它使用另一种颜色来产生一种特殊的三维效果。注意，只有那些升起（raised）或下沉（sunken）的Box、HLine和VLine边框才会有中线。 

• •.边框宽度（frame width）由边框类型（frame style）决定，可以用frameWidth()函数来取得为当前使用的类型而定义的值。 

边框和边框里的内容之间的间隔（margin）可使用QWidget::setContentsMargins()函数来设置。

下面的表格显示的是某些类型（styles）和线宽（line widths）的组合所产生的边框的外观：

BioPython教程翻译：6.1分析或读取序列比对，6.1  Parsing or Reading Sequence Alignments

6.1  分析或读取序列比对

我们有两个用于读取序列比对的函数，Bio.AlignIO.read()和Bio.AlignIO.parse()，它们与Bio.SeqIO 中的对应函数的分工是一样的，一个用来读取只有一条比对的文件，另一个用来读取有多条比对的文件。

使用Bio.AlignIO.parse()的话，会返回一个迭代器，它指向MultipleSeqAlignment 对象。迭代器通常是在一个for 循环中使用的。比如以下例子：你有很多不同的比对，它们包括来自PHYLIP 工具seqboot 的重采样比对、或者来自EMBOSS 工具water 或needle 或Bill Pearson 的FASTA 工具的多个成对的比对。

然而，很多时候，你所研究的文件中只有一条比对。在这种情况下，你应当使用Bio.AlignIO.read()函数，它返回单个MultipleSeqAlignment 对象。

这2个函数都有2个必选参数：

1. 1.第一个参数是一个用来读取数据的把柄（handle），典型地，是一个打开的文件（参见20.1小节），或者是一个文件名。 

2. 2.第二个参数是一个小写的字符串，指定比对的格式。就像在Bio.SeqIO 中一样，我们不会尝试为你猜测那个格式！参见http://biopython.org/wiki/AlignIO，那里有被支持的格式的完整列表。 

另外还有一个可选的seq_count 参数，我们将在下面的6.1.3 小节中说明它，它是用来对付那些有歧义的可能包含多条比对信息的文件格式的。

Biopython 1.49中还引入咯另一个可选参数alphabet，它允许你指定一个预期的字符集（alphabet）。这个选项会有用的，因为很多比对文件格式中都没有显式指明它们的序列是RNA、DNA 还是蛋白质序列–那就意味着Bio.AlignIO 会使用默认的通用字符集。

6.1.1  单条比对信息

举个例子，看看下面带有丰富注释（annotation rich）的蛋白质比对信息，以PFAM 或Stockholm 文件格式存储的：

# STOCKHOLM 1.0

#=GS COATB_BPIKE/30-81  AC P03620.1

#=GS COATB_BPIKE/30-81  DR PDB; 1ifl ; 1-52;

#=GS Q9T0Q8_BPIKE/1-52  AC Q9T0Q8.1

#=GS COATB_BPI22/32-83  AC P15416.1

#=GS COATB_BPM13/24-72  AC P69541.1

#=GS COATB_BPM13/24-72  DR PDB; 2cpb ; 1-49;

#=GS COATB_BPM13/24-72  DR PDB; 2cps ; 1-49;

#=GS COATB_BPZJ2/1-49   AC P03618.1

#=GS Q9T0Q9_BPFD/1-49   AC Q9T0Q9.1

#=GS Q9T0Q9_BPFD/1-49   DR PDB; 1nh4 A; 1-49;

#=GS COATB_BPIF1/22-73  AC P03619.2

#=GS COATB_BPIF1/22-73  DR PDB; 1ifk ; 1-50;

COATB_BPIKE/30-81             AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIRLFKKFSSKA

#=GR COATB_BPIKE/30-81  SS    -HHHHHHHHHHHHHH–HHHHHHHH–HHHHHHHHHHHHHHHHHHHHH—-

Q9T0Q8_BPIKE/1-52             AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIKLFKKFVSRA

COATB_BPI22/32-83             DGTSTATSYATEAMNSLKTQATDLIDQTWPVVTSVAVAGLAIRLFKKFSSKA

COATB_BPM13/24-72             AEGDDP…AKAAFNSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFTSKA

#=GR COATB_BPM13/24-72  SS    —S-T…CHCHHHHCCCCTCCCTTCHHHHHHHHHHHHHHHHHHHHCTT–

COATB_BPZJ2/1-49              AEGDDP…AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFASKA

Q9T0Q9_BPFD/1-49              AEGDDP…AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFTSKA

#=GR Q9T0Q9_BPFD/1-49   SS    ——…-HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH–

COATB_BPIF1/22-73             FAADDATSQAKAAFDSLTAQATEMSGYAWALVVLVVGATVGIKLFKKFVSRA

#=GR COATB_BPIF1/22-73  SS    XX-HHHH–HHHHHH–HHHHHHH–HHHHHHHHHHHHHHHHHHHHHHH—

#=GC SS_cons                  XHHHHHHHHHHHHHHHCHHHHHHHHCHHHHHHHHHHHHHHHHHHHHHHHC–

#=GC seq_cons                 AEssss…AptAhDSLpspAT-hIu.sWshVsslVsAsluIKLFKKFsSKA

//

这是Phage_Coat_Gp8 (PF05371)那个PFAM 条目的种子（seed）比对，是从现已过时的PFAM 版本http://pfam.sanger.ac.uk/上下载回来的。我们可以用下面的代码来载入这个文件（假设它已经保存到当前工作目录中，文件名为“PF05371_seed.sth”）：

>>> from Bio import AlignIO

>>> alignment = AlignIO.read(“PF05371_seed.sth”, “stockholm”)

以下代码会输入这个比对信息的概要内容：

>>> print alignment

SingleLetterAlphabet() alignment with 7 rows and 52 columns

AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIRL…SKA COATB_BPIKE/30-81

AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIKL…SRA Q9T0Q8_BPIKE/1-52

DGTSTATSYATEAMNSLKTQATDLIDQTWPVVTSVAVAGLAIRL…SKA COATB_BPI22/32-83

AEGDDP—AKAAFNSLQASATEYIGYAWAMVVVIVGATIGIKL…SKA COATB_BPM13/24-72

AEGDDP—AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKL…SKA COATB_BPZJ2/1-49

AEGDDP—AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKL…SKA Q9T0Q9_BPFD/1-49

FAADDATSQAKAAFDSLTAQATEMSGYAWALVVLVVGATVGIKL…SRA COATB_BPIF1/22-73

你应该会注意到，在上面的输出内容中，那些序列都被省略咯一部分。我们可以自己写代码来输出这些东西，把那些行当成 SeqRecord 对象来遍历：

>>> from Bio import AlignIO

>>> alignment = AlignIO.read(“PF05371_seed.sth”, “stockholm”)

>>> print “Alignment length %i” % alignment.get_alignment_length()

Alignment length 52

>>> for record in alignment:

…     print “%s – %s” % (record.seq, record.id)

AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIRLFKKFSSKA – COATB_BPIKE/30-81

AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIKLFKKFVSRA – Q9T0Q8_BPIKE/1-52

DGTSTATSYATEAMNSLKTQATDLIDQTWPVVTSVAVAGLAIRLFKKFSSKA – COATB_BPI22/32-83

AEGDDP—AKAAFNSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFTSKA – COATB_BPM13/24-72

AEGDDP—AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFASKA – COATB_BPZJ2/1-49

AEGDDP—AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFTSKA – Q9T0Q9_BPFD/1-49

FAADDATSQAKAAFDSLTAQATEMSGYAWALVVLVVGATVGIKLFKKFVSRA – COATB_BPIF1/22-73

你还可以使用比对信息对象的format 方法来以特定文件格式显示它–参见6.2.2 小节以了解细节。

你有没有注意到？在上面的原始文件中，很多序列都包含咯数据库交叉引用信息，指向PDB 和关联的已知二级（secondary）结构。试试看：

>>> for record in alignment:

…     if record.dbxrefs:

…         print record.id, record.dbxrefs

COATB_BPIKE/30-81 ['PDB; 1ifl ; 1-52;']

COATB_BPM13/24-72 ['PDB; 2cpb ; 1-49;', 'PDB; 2cps ; 1-49;']

Q9T0Q9_BPFD/1-49 ['PDB; 1nh4 A; 1-49;']

COATB_BPIF1/22-73 ['PDB; 1ifk ; 1-50;']

要看看所有序列的注释的话，试试这样：

>>> for record in alignment:

…     print record

Sanger在http://pfam.sanger.ac.uk/family?acc=PF05371 提供咯一个漂亮的网页界面，它允许你以其它格式下载这个文件。这是FASTA 格式的样子：

>COATB_BPIKE/30-81

AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIRLFKKFSSKA

>Q9T0Q8_BPIKE/1-52

AEPNAATNYATEAMDSLKTQAIDLISQTWPVVTTVVVAGLVIKLFKKFVSRA

>COATB_BPI22/32-83

DGTSTATSYATEAMNSLKTQATDLIDQTWPVVTSVAVAGLAIRLFKKFSSKA

>COATB_BPM13/24-72

AEGDDP—AKAAFNSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFTSKA

>COATB_BPZJ2/1-49

AEGDDP—AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFASKA

>Q9T0Q9_BPFD/1-49

AEGDDP—AKAAFDSLQASATEYIGYAWAMVVVIVGATIGIKLFKKFTSKA

>COATB_BPIF1/22-73

FAADDATSQAKAAFDSLTAQATEMSGYAWALVVLVVGATVGIKLFKKFVSRA

注意，那个网页上应当有一个选项，控制的是把缺口（gaps）显示成点还是减号，我们在上面是显示成减号的。假设你下载咯它，并且保存成“PF05371_seed.faa”，那么你就可以使用几乎相同的代码来载入它咯：

from Bio import AlignIO

alignment = AlignIO.read(“PF05371_seed.faa”, “fasta”)

print alignment

这个代码里面的变化仅仅是文件名和格式字符串。你会得到相同的输出，序列和记录标识符都是相同的。然而，你可能也会猜到，如果你查看每个SeqRecord 的话，将会发现没有注释也没有数据库交叉引用，因为FASTA 文件格式中没有这些东西。

注意，除咯使用Sanger 网页之外，你还可以使用Bio.AlignIO 来亲自将原来的Stockholm 格式的文件转换成 FASTA 文件（看下面的内容）。

对于任意受支持的文件格式，你都可以使用完全相同的方式来载入一条比对信息，仅仅需要改变格式字符串。比如，使用“phylip”来读取PHYLIP 文件、使用“nexus”来读取NEXUS 文件、使用“emboss”来读取EMBOSS 工具输出的比对文件。在维基页面（http://biopython.org/wiki/AlignIO）和内置文档（也可在线看）中有一个完整的列表：

>>> from Bio import AlignIO

>>> help(AlignIO)

…

6.1.2  多条比对信息

前一小节关注的是读取只包含单条比对信息的文件。然而，通常，文件中可以包含多条比对信息，要读取这些文件的话，我们必须使用Bio.AlignIO.parse()函数。

假设你有一条很短的比对信息，是PHYLIP 格式的：

    5    6

Alpha     AACAAC

Beta      AACCCC

Gamma     ACCAAC

Delta     CCACCA

Epsilon   CCAAAC

如果你想要使用PHYLIP 工具来引导（bootstrap）一个系统发生史（phylogenetic）树的话，那么，其中的一个步骤就是，使用bootseq 工具创建一组重采样（resampled）过的比对信息。输出的内容是这样的，其中省略咯一些东西：

    5     6

Alpha     AAACCA

Beta      AAACCC

Gamma     ACCCCA

Delta     CCCAAC

Epsilon   CCCAAA

    5     6

Alpha     AAACAA

Beta      AAACCC

Gamma     ACCCAA

Delta     CCCACC

Epsilon   CCCAAA

    5     6

Alpha     AAAAAC

Beta      AAACCC

Gamma     AACAAC

Delta     CCCCCA

Epsilon   CCCAAC

…

    5     6

Alpha     AAAACC

Beta      ACCCCC

Gamma     AAAACC

Delta     CCCCAA

Epsilon   CAAACC

如果你想使用Bio.AlignIO 来读入这个的话，你可以这样：

from Bio import AlignIO

alignments = AlignIO.parse(“resampled.phy”, “phylip”)

for alignment in alignments:

    print alignment

    print

将会产生以下输出，也是省略咯一些东西的：

SingleLetterAlphabet() alignment with 5 rows and 6 columns

AAACCA Alpha

AAACCC Beta

ACCCCA Gamma

CCCAAC Delta

CCCAAA Epsilon

 

SingleLetterAlphabet() alignment with 5 rows and 6 columns

AAACAA Alpha

AAACCC Beta

ACCCAA Gamma

CCCACC Delta

CCCAAA Epsilon

 

SingleLetterAlphabet() alignment with 5 rows and 6 columns

AAAAAC Alpha

AAACCC Beta

AACAAC Gamma

CCCCCA Delta

CCCAAC Epsilon

 

…

 

SingleLetterAlphabet() alignment with 5 rows and 6 columns

AAAACC Alpha

ACCCCC Beta

AAAACC Gamma

CCCCAA Delta

CAAACC Epsilon

就像使用Bio.SeqIO.parse()函数一样，使用Bio.AlignIO.parse()的时候也会返回一个迭代器。如果你想同时在内存中保存全部的比对信息，以便以任意顺序访问它们的话，就把那个迭代器转换成一个列表：

from Bio import AlignIO

alignments = list(AlignIO.parse(“resampled.phy”, “phylip”))

last_align = alignments[-1]

first_align = alignments[0]

6.1.3  歧义性比对信息

很多比对文件格式都能显式储存多条比对信息，并且明显地标出各条比对信息之间的间隔。然而，如果使用的是一个通用的序列文件格式的话，就没有这种块状的结构。最常见的情形就是使用FASTA 文件来存储比对信息的情况。比如，看看下面的内容：

>Alpha

ACTACGACTAGCTCAG–G

>Beta

ACTACCGCTAGCTCAGAAG

>Gamma

ACTACGGCTAGCACAGAAG

>Alpha

ACTACGACTAGCTCAGG–

>Beta

ACTACCGCTAGCTCAGAAG

>Gamma

ACTACGGCTAGCACAGAAG

这个东西有可能是一个包含6个序列的单条比对信息（其中有重复的标识符）。或者，根据标识符判断，这可能是2个不同的比对信息，每个都有3个序列，并且它们的长度碰巧相同。

下一个例子勒？

>Alpha

ACTACGACTAGCTCAG–G

>Beta

ACTACCGCTAGCTCAGAAG

>Alpha

ACTACGACTAGCTCAGG–

>Gamma

ACTACGGCTAGCACAGAAG

>Alpha

ACTACGACTAGCTCAGG–

>Delta

ACTACGGCTAGCACAGAAG

同样地，这个东西有可能是一个包含6个序列的单条比对信息。然而，根据标识符来看，我们可以猜测，这是3个成对的比对信息，碰巧长度都一样。

最后勒个例子也类似：

>Alpha

ACTACGACTAGCTCAG–G

>XXX

ACTACCGCTAGCTCAGAAG

>Alpha

ACTACGACTAGCTCAGG

>YYY

ACTACGGCAAGCACAGG

>Alpha

–ACTACGAC–TAGCTCAGG

>ZZZ

GGACTACGACAATAGCTCAGG

在第三个例子中，由于长度不同，所以不能当成包含6个序列的单条比对信息。然而，它可能是3条成对的比对信息。

显然，在一个FASTA 文件里保存多条比对信息是不合适的。然而，如果你不得不使用这种输入文件的话，Bio.AlignIO可能对付最普通的情况，那种情况下所有的比对信息都有相同的记录个数。一个例子就是一系列的成对比对信息，它们可能是由EMBOSS 工具needle 和water 生成的–当然，在这种情况下，Bio.AlignIO应当能够理解它们的原配（native）输出格式，使用“emboss”作为格式字符串。

要将这些FASTA 文件例子解释成多个单独的比对信息的话，我们可以使用Bio.AlignIO.parse()，并且使用可选的seq_count 参数，它指定的是预期在每个比对信息中出现多少个序列（在这些例子中，分别是 3、2和2）。比如，用第三个例子做输入数据：

for alignment in AlignIO.parse(handle, “fasta”, seq_count=2):

    print “Alignment length %i” % alignment.get_alignment_length()

    for record in alignment:

        print “%s – %s” % (record.seq, record.id)

    print

输出：

Alignment length 19

ACTACGACTAGCTCAG–G – Alpha

ACTACCGCTAGCTCAGAAG – XXX

 

Alignment length 17

ACTACGACTAGCTCAGG – Alpha

ACTACGGCAAGCACAGG – YYY

 

Alignment length 21

–ACTACGAC–TAGCTCAGG – Alpha

GGACTACGACAATAGCTCAGG – ZZZ

对于前2个例子，使用Bio.AlignIO.read()或者不带seq_count参数的Bio.AlignIO.parse()的话，会输出单条比对信息，其中包含6个序列。对于第三个例子，会抛出一个异常，因为它们的长度不同，无法组成一个单条比对信息。

如果那个文件格式自身有一个块结构，使得Bio.AlignIO 能够直接确定每个比对信息里的序列个数的话，那么就不需要seq_count 参数。如果提供咯这个参数，却又与文件内容中的不一致的话，就会产生一个错误。

注意，这个可选的seq_count 参数假设文件中的每个比对信息中有相同个数的序列。假设你可能遇到奇怪的情况，比如说一个包含拥有不同序列个数的多条比对信息的FASTA 文件–当然，我很想能听说在真实世界中有这样的例子。假设你无法弄到一个有良好的文件格式的数据的话，那就没有简单的使用Bio.AlignIO 来处理的方法。在这种情况下，你可以考虑使用Bio.SeqIO 将那些序列读入并且统一处理一下，再创建适当的比对文件。

Qt4.7.0文档翻译：QtTest模块，QtTest Module

那些使用Qt的单元测试类的程序需要与QtTest 模块链接起来。要包含这个模块的类的定义的话，需要使用以下指令：

 #include <QtTest>

要与这个模块链接，就将下面一行添加到你的qmake的.pro文件中：

 CONFIG += qtestlib

参见QTestLib手册，以了解关于如何在你的程序中使用 Qt的单元测试功能的细节。

QtTest 模块是所有的Qt版本的一部分。

Qt4.7.0文档翻译：QSignalSpy类参考，QSignalSpy Class Reference

QSignalSpy类使得你可以对信号的发射过程进行监视（introspection）。

QSignalSpy可以连接到任何对象的任何信号，并且记录它的发射情况。QSignalSpy本身是一个由QVariant列表组成的列表。信号的每次发射都会向列表中追加一个条目，其中包含咯那个信号的参数。

下面的例子记录一个QCheckBox的clicked()信号的全部发射情况：

 QCheckBox *box = …;

 QSignalSpy spy(box, SIGNAL(clicked(bool)));

 //触发这个信号

 box->animateClick();

 QCOMPARE(spy.count(), 1); //确保这个信号只发射一次

 QList<QVariant> arguments = spy.takeFirst(); //取出第一个信号

 QVERIFY(arguments.at(0).toBool() == true); //验证第一个参数

spy.takeFirst()返回第一个发射的信号的参数，以一个QVariant对象列表的形式返回。clicked()信号只有一个逻辑值参数，它存储在参数列表的第一个条目中。

下面的例子会捕捉来自一个自定义对象的某个信号：

 QSignalSpy spy(myCustomObject, SIGNAL(mySignal(int, QString, double)));

 myCustomObject->doSomething(); //触发信号的发射过程

 QList<QVariant> arguments = spy.takeFirst();

 QVERIFY(arguments.at(0).type() == QVariant::Int);

 QVERIFY(arguments.at(1).type() == QVariant::QString);

 QVERIFY(arguments.at(2).type() == QVariant::double);

注意：在你创建一个QSignalSpy 之前，需要使用qRegisterMetaType()函数来把非标准的数据类型注册一下。比如：

 qRegisterMetaType<QModelIndex>(“QModelIndex”);

 QSignalSpy spy(&model, SIGNAL(whatever(QModelIndex)));

要想取出那个QModelIndex，你可以使用qvariant_cast：

 //从接收到的第一个信号取出第一个参数：

 QModelIndex result = qvariant_cast<QModelIndex>(spy.at(0).at(0));

Qt4.7.0文档翻译：QObject类参考，QObject Class Reference

本文来自Kate dNA的勃客：http://stupidbeauty.com/KNA/2011/05/qt4-7-0文档翻译：qobject类参考，qobject-class-reference/

bool QObject::connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * method, Qt::ConnectionType type = Qt::AutoConnection ) [static]

创建一个从sender对象的signal信号到receiver对象的method方法的一个type类型的连接。如果连接成功的话，返回真；否则返回假。

在指定signal信号和method方法时，你必须使用SIGNAL()和SLOT()宏，比如：

QLabel *label = new QLabel;

QScrollBar *scrollBar = new QScrollBar;

QObject::connect(scrollBar, SIGNAL(valueChanged(int)),

label, SLOT(setNum(int)));

这个例子确保咯那个文本标签一直显示出滚动条的当前值。注意，信号和信号槽参数中不能有任何的变量名，只能有类型名。比如，下面的代码就会出错：

// 错的

QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),

label, SLOT(setNum(int value)));

一个信号也可以连接到另一个信号：

class MyWidget : public QWidget

{

Q_OBJECT

public:

MyWidget();

signals:

void buttonClicked();

private:

QPushButton *myButton;

};

MyWidget::MyWidget()

{

myButton = new QPushButton(this);

connect(myButton, SIGNAL(clicked()),

this, SIGNAL(buttonClicked()));

}

在这个例子中，MyWidget构造函数将一个私有成员变量的一个信号连接到一个与MyWidget相关的名字上，使得外面可以访问它。

一个信号可以连接到很多个信号槽和信号上。还可以把很多信号连接到同一个信号槽上。

如果一个信号被连接到多个信号槽的话，那么，当那个信号被发射时，那些信号槽会按照连接时的顺序被触发。

如果这个函数成功地将信号连接到信号槽的话，它就会返回真。如果它无法创建那个连接的话，它会返回假，比如：QObject无法验证signal和method的存在性，或者它们的特征（signatures）不兼容。

默认地，针对你进行的每个连接，都会发射一个信号；对于重复的连接勒，会发射两个信号。你可以通过调用一次disconnect()来打破所有的这些连接。如果你传入的type参数是Qt::UniqueConnection的话，那么，只有在连接没有重复的情况下才会被建立。如果已经有一个相同连接（duplicate）（完全相同的对象上完全相同的信号和完全相同的信号槽），那么这个连接会失败，并且返回假。

可选的参数type指定的是要建立的连接的类型。特别地，它决定咯：某个特定的信号是立即传递到一个信号槽上还是放到队列里稍后再传递。如果信号是放到队列中，那么它的参数必须是 Qt的元对象（meta-object）系统能识别的类型，因为Qt 需要复制那些参数，将它们存储在一个事件中。如果你试着使用一个排队的连接，而产生咯以下错误消息的话

QObject::connect: Cannot queue arguments of type ‘MyType’

(Make sure ‘MyType’ is registered using qRegisterMetaType().)

那么就在你建立连接之前调用qRegisterMetaType()来将这个数据类型注册一下。

注意：这个函数是线程安全的（thread-safe）。

参见disconnect()、sender()和qRegisterMetaType()。