序列输入// 输出

1 分析或读取序列

         Bio.SeqIO.parse()将序列数据读成 SeqRecord 对象。它有两个参数:第一个参数是要读取的 handle。handle 是一个要读的打开文件,但是可以从命令行输出,或者可以从网上下载。第二个参数是一个小写的序列特征格式--我们不会为你猜想文件格式。到

http://biopython.org/wiki/SeqIO 查 看 支 持 的 文 件 格 式 。 这 会 返 回 一 个 给 出SeqRecord 对象的迭代器,它主要用于 for 循环中。有时你会发现自己在处理仅仅包含单一记录的文件。对于此种情况,Biopython 1.45 引入了 Bio.SeqIO.read()函数。这也使用 handle 和格式作为参数。如果有一个或仅仅一个记录,将作为一个 SeqRecord 对象返回。

1.1 读取序列文件

总体上来将 Bio.SeqIO.parse() 是用来读取序列文件并作为 SeqRecord 对 象 ,往往用在 for 循环中:

from Bio import SeqIO
handle = open("ls_orchid.fasta")
for seq_record in SeqIO.parse(handle, "fasta") :
print seq_record.id
print repr(seq_record.seq)
print len(seq_record.seq)

handle.close()

这个例子是 2.4 节的,它会载入包含 orchid DNA 序列的 FASTA 格式文件
19Biopython 中文指南
生物信息学论坛 http://www.bioxxx.cn 倾力奉献
ls_orchid.fasta. 如果想载入一个 GenBank 格式文件,例如 ls_orchid.gbk,改下文
件名和格式就可以了:
from Bio import SeqIO
handle = open("ls_orchid.gbk")
for seq_record in SeqIO.parse(handle, "genbank") :
print seq_record.id
print seq_record.seq
print len(seq_record.seq)
handle.close()
类似的,如果你想读取另一种文件格式的文件,同时假定 Bio.SeqIO.parse()支持该格式,你需要做的就是将格式字符串改为合适的,例如 "swiss"代表SwissProt 文件,或者"embl"代表 EMBL 文本文件。具体文件格式列表可参看 wiki页面 (http://biopython.org/wiki/SeqIO).

1.2 在序列文件中重复记录

在以上的例子中,我们往往使用 for 循环来遍历记录。你可以使用 for 循环和其他支持遍历的 python 对象(列表,元组及字符串)。Bio.SeqIO 返回的对象往往是 SeqRecord 对象的遍历。你需要轮流查看每一个记录,但是仅仅一次。附加一点是当你处理大文件时,使用 iterator 会节约你的内存。除了使用 for 循 环 ,你也可以使用.next()方法来逐步调试条目:
from Bio import SeqIO
handle = open("ls_orchid.fasta")
record_iterator = SeqIO.parse(handle, "fasta")
first_record = record_iterator.next()
print first_record.id
print first_record.description
second_record = record_iterator.next()
print second_record.id
print second_record.description
handle.close()

如果你使用.next(),没有更多的结果,你将得到一个特殊的 python 对象 None或者一个 StopIteration 错误。我们也考虑了一个特殊的情况,当你的序列文件中包含多个记录,但是你仅仅想要第一个。这种情况下,以下代码就很简明:

from Bio import SeqIO
first_record = SeqIO.parse(open("ls_orchid.gbk"), "genbank").next()

一个注意事项--像这样使用.next()方法将会忽略文件中任何添加的记录。当你的文件中仅仅有一条记录时,就像这一章中的某些在线的例子,或者包含单个染色体的 GenBank 文件,那么使用新的 Bio.SeqIO.read()函数替代。这将会检查是否有其他非期待的记录存在。

1.3 在一个序列文件

在前一节中,我们讨论了 Bio.SeqIO.parse()给出 SeqRecord 遍历,你逐个的得到了记录。最常用的是使用两一个顺序来存取记录。 Python 列表数据类型很适合这个,我们可以使用 list()把记录遍历转变为一个包含 SeqRecord 对象的列表:
from Bio import SeqIO
handle = open("ls_orchid.gbk")
records = list(SeqIO.parse(handle, "genbank"))
handle.close()
print "Found %i records" % len(records)
print "The last record"
last_record = records[-1] #using Python's list tricks
print last_record.id
print repr(last_record.seq)
print len(last_record.seq)
print "The first record"
first_record = records[0] #remember, Python counts from zero
print first_record.id
print repr(first_record.seq)
print len(first_record.seq)
Giving:
Found 94 records

The last record
Z78439.1
Seq('CATTGTTGAGATCACATAATAATTGATCGAGTTAATCTGGAGGATCTGT
TTACT...GCC', IUPACAmbiguousDNA())
592
The first record
Z78533.1
Seq('CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGATGAGA
CCGTGG...CGC', IUPACAmbiguousDNA())
740

当然,你一可以继续对 SeqRecord 对象列表使用 for 循环。使用一个 list 比一个 iterator 更灵活(例如,你可以通过 list 长度来确定记录的数目),但是会使用更多的内存,因为它把记录一次性全部包括在内存里。

1.4 提取数据

假定你想要从 ls_orchid.gbk 文件中提取物种列表。让我们先来看下文件的第一条记录,看下物种信息存储在那个部分。
from Bio import SeqIO
record_iterator = SeqIO.parse(open("ls_orchid.gbk"), "genbank")
first_record = record_iterator.next()
print first_record
会给出以下的信息:
ID: Z78533.1
Name: Z78533
Desription: C.irapeanum 5.8S rRNA gene and ITS1 and ITS2 DNA.
/source=Cypripedium irapeanum
/taxonomy=['Eukaryota', 'Viridiplantae', 'Streptophyta', ..., 'Cypripedium']
/keywords=['5.8S ribosomal RNA', '5.8S rRNA gene', 'internal transcribed spacer',
'ITS1', 'ITS2']
/references=[...]
/accessions=['Z78533']
/data_file_division=PLN
/date=30-NOV-2006
/organism=Cypripedium irapeanum
/gi=2765658

Seq('CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGATGAGACCGTGG...CGC', IUPACAmbiguousDNA())

我们所需要的信息 Cypripedium irapeanum 存储在注释字典,在 source 和organism 后,因此,我们可以这样获得:
print first_record.annotations["source"]或者:print first_record.annotations["organism"]一般来说, organism 是用在科学命名上(拉丁语) ,source 是一个通常的名字 。在这个例子中,像平常一样,它们是一致的。现在让我们遍历所有记录,构建一个每一个 orchid 序列组成的物种的列表:
from Bio import SeqIO
handle = open("ls_orchid.gbk")
all_species = []
for seq_record in SeqIO.parse(handle, "genbank") :
all_species.append(seq_record.annotations["organism"])
handle.close()

print all_specie

另一个方法是使用列表 comprehension:
from Bio import SeqIO
all_species
=
[seq_record.annotations["organism"]
for
seq_record
in
SeqIO.parse(open("ls_orchid.gbk"), "genbank")]
print all_species
不管哪一个方法,结果是:
['Cypripedium irapeanum', 'Cypripedium californicum', ..., 'Paphiopedilumbarbatum']
很好,这很容易,因为 GenBank 文件是使用标准方式进行注释的。现在,假设你想从 FASTA 文件,而不是 GenBank 文件中提取物种的列表。坏消息是你需要写一些代码从记录描述行提取你想要的数据--如果信息是在文件中的第一个位置。对于这个例子,注意,如果你使用空格分解描述行,那样的话,物种处于第 1 个位置(第 0 位置是记录标识符)。因此我们可以这样做:
from Bio import SeqIO
handle = open("ls_orchid.fasta")
all_species = []
for seq_record in SeqIO.parse(handle, "fasta") :
all_species.append(seq_record.description.split()[1])
handle.close()
print all_species
给出:
['C.irapeanum', 'C.californicum', 'C.fasciculatum', 'C.margaritaceum', ..., 'P.barbatum']
更简介的使用 list comprehension 方法:
from Bio import SeqIO
all_species
=
[seq_record.description.split()[1]
for
seq_record
in
SeqIO.parse(open("ls_orchid.fasta"), "fasta")]
print all_species

一般来说,从 FASTA 描述行提取信息并不是十分顺利,如果使用更好的注释文件格式,例如 GenBank 或 EMBL,这种注释信息分类将会更容易处理。

2 从网上分析序列

在先前的章节中,我们从一个文件 handle 来分析序列数据。我们暗示 handles并不总是来自于文件,在本节中,将使用 handles 连接网络下载序列。注意,因为你可以下载序列数据,并且分析成 SeqRecord 对象,这并意味着总是一个好的主意。一般来说,你需要下载序列,保存以备重用的。

2.1 从网上分析 GenBank 记录

现在我们仅仅连接到 NCBI使用它们的 GI 号从 GenBank 中得到些 orchid 的蛋白质。首先,我们先提取一个记录。记住,当你希望 handle 包含仅仅一个记录时,使用 Bio.SeqIO.read() 函数 :

rom Bio import Entrez
form Bio import SeqIO
handle = Entrez.efetch(db="protein", rettype="genbank", id="6273291")
seq_record = SeqIO.read(handle, "genbank")
handle.close()
print "%s with %i features" % (seq_record.id, len(seq_record.features))
期望输出为:
gi|6273291|gb|AF191665.1|AF191665 with 3 features
NCBI 同时会让你选择其他格式,例如 FASTA 文件。如果你不关心 GenBank文件中的注释和特性,那会是一个很好的下载选择,因为它更小些:
from Bio import Entrez
form Bio import SeqIO
handle = Entrez.efetch(db="protein", rettype="fasta", id="6273291")
seq_record = SeqIO.read(handle, "fasta")
handle.close()
print "%s with %i features" % (seq_record.id, len(seq_record.features))
期望输出:
gi|6273291|gb|AF191665.1|AF191665 with 0 features
现在让我们取回更多的记录。这次,handle 包含多条记录,因此我们需要使
用 Bio.SeqIO.parse() 函数:
from Bio import Entrez
form Bio import SeqIO
handle = Entrez.efetch(db="protein", rettype="genbank", id="6273291,6273290,627
3289")
for seq_record in SeqIO.parse(handle, "genbank") :
print seq_record.id, seq_record.description[:50] + "..."
print "Sequence length %i," % len(seq_record),
print "%i features," % len(seq_record.features),

print "from: %s" % seq_record.annotations['source']

handle.close()
将给出以下的输出:
AF191665.1 Opuntia marenae rpl16 gene; chloroplast gene for c...
Sequence length 902, 3 features, from: chloroplast Opuntia marenae
AF191664.1 Opuntia clavata rpl16 gene; chloroplast gene for c...
Sequence length 899, 3 features, from: chloroplast Grusonia clavata
AF191663.1 Opuntia bradtiana rpl16 gene; chloroplast gene for...
Sequence length 899, 3 features, from: chloroplast Opuntia bradtianaa
查看第七章关于 Bio.Entrez 模块的更多信息,确信你读了 NCBI 使用 Entrez

2.2 从网上分析 SwissProt 序列

现在让我们使用 handle 从 ExPASy 下载一个 SwissProt 文件,更多内容在第8章。正如上面所讲,Bio.SeqIO.read()函数包含在 1.45 版本(或更高)中。
from Bio import ExPASy
from Bio import SeqIO
handle = ExPASy.get_sprot_raw("O23729")
seq_record = SeqIO.read(handle, "swiss")
handle.close()
print seq_record.id
print seq_record.name
print seq_record.description
print repr(seq_record.seq)
print "Length %i" % len(seq_record)
print seq_record.annotations['keywords']
假定你的网络连接通畅,你会得到以下返回结果:
O23729
CHS3_BROFI
Chalcone synthase 3 (EC 2.3.1.74) (Naringenin-chalcone synthase 3).
Seq('MAPAMEEIRQAQRAEGPAAVLAIGTSTPPNALYQADYPDYYFRITKSEHLTELK...GAE', ProteinAlphabet())
Length 394
['Acyltransferase', 'Flavonoid biosynthesis', 'Transferase']

3 序列文件作为字典

下一件事我们需要做的是,使用 python 的字典数据类型,就像在数据库里索引和定位 orchid 文件一样。对于大的文件这是很有用的,因为你仅仅需要存取文件的某个元素,做成一个好的快速的数据库。你可以使用 SeqIO.to_dict()函数来生成一个 SeqRecord 字典(在内存里)。默认的,这将使用到每一个记录的标识符(id)作为关键词。让我们用 GenBank 文件试一下:
from Bio import SeqIO
handle = open("ls_orchid.gbk")
orchid_dict = SeqIO.to_dict(SeqIO.parse(handle, "genbank"))
handle.close()
由于这个可变的 orchid_dict 成为一个 python 字典,我们可以使用我们已有
的所有关键词进行查找:
>>> print orchid_dict.keys()
['Z78484.1', 'Z78464.1', 'Z78455.1', 'Z78442.1', 'Z78532.1', 'Z78453.1', ..., 'Z78471.1']
我们可以通过关键词来存取一个单 SeqRecord 对象,就像平常一样控制该对象:
>>> seq_record = orchid_dict["Z78475.1"]
>>> print seq_record.description
P.supardii 5.8S rRNA gene and ITS1 and ITS2 DNA
>>> print repr(seq_record.seq)
Seq('CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGA
TCACAT...GGT', IUPACAmbiguousDNA())
所以,很容易创建一个内存里的关于 GenBank 记录的数据库。接下来,我

们将使用 FASTA 格式来试一下。

3.1 写入序列文件

          我们将讨论使用 Bio.SeqIO.parse()进行序列输入(读取文件),现在,我们将看一下 Bio.SeqIO.write()进行序列输出(写入文件)。这个函数包含有三个变量:一些 SeqRecord 对象,一个要写入的 handle 及一个序列格式。这里有一个例子,我们以创建一些 SeqRecord 对象开始(手动,而非从一个文件载入)

from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
from Bio.Alphabet import generic_protein
rec1
=
SeqRecord(Seq("MMYQQGCFAGGTVLRLAKDLAENNRGARVLVVCSEITAVTF
RGPSETHLDSMVGQALFGD" \
+"GAGAVIVGSDPDLSVERPLYELVWTGATLLPDSEGAIDGHLREV
GLTFHLLKDVPGLISK" \
+"NIEKSLKEAFTPLGISDWNSTFWIAHPGGPAILDQVEAKLGLKE
EKMRATREVLSEYGNM" \
+"SSAC", generic_protein),
id="gi|14150838|gb|AAK54648.1|AF376133_1",
description="chalcone synthase [Cucumis sativus]")
rec2
=
SeqRecord(Seq("YPDYYFRITNREHKAELKEKFQRMCDKSMIKKRYMYLTEEIL
KENPSMCEYMAPSLDARQ" \
+"DMVVVEIPKLGKEAAVKAIKEWGQ", generic_protein),
id="gi|13919613|gb|AAK33142.1|",
description="chalcone synthase [Fragaria vesca subsp. bracteata]")
rec3
=
SeqRecord(Seq("MVTVEEFRRAQCAEGPATVMAIGTATPSNCVDQSTYPDYYFR
ITNSEHKVELKEKFKRMC" \
+"EKSMIKKRYMHLTEEILKENPNICAYMAPSLDARQDIVVVEVP
KLGKEAAQKAIKEWGQP" \
+"KSKITHLVFCTTSGVDMPGCDYQLTKLLGLRPSVKRFMMYQQ
GCFAGGTVLRMAKDLAEN" \
+"NKGARVLVVCSEITAVTFRGPNDTHLDSLVGQALFGDGAAAVII
GSDPIPEVERPLFELV" \
+"SAAQTLLPDSEGAIDGHLREVGLTFHLLKDVPGLISKNIEKSLVE
AFQPLGISDWNSLFW" \

+"IAHPGGPAILDQVELKLGLKQEKLKATRKVLSNYGNMSSACVL
FILDEMRKASAKEGLGT" \
+"TGEGLEWGVLFGFGPGLTVETVVLHSVAT", generic_protein),
id="gi|13925890|gb|AAK49457.1|",
description="chalcone synthase [Nicotiana tabacum]")
my_records = [rec1, rec2, rec3]
现在我们有了一个 SeqRecord 对象列表,我们将把它们写入到一个 FASTA
格式文件中。
from Bio import SeqIO
handle = open("my_example.fasta", "w")
# 原文中为 faa
SeqIO.write(my_records, handle, "fasta")
handle.close()
在你最喜欢的文本编辑器中打开这个文件,你可以得到像下面的结果::
>gi|14150838|gb|AAK54648.1|AF376133_1 chalcone synthase [Cucumis sativus]
MMYQQGCFAGGTVLRLAKDLAENNRGARVLVVCSEITAVTFRGPSETHLDSMVGQALFGDGAGAVIVGSDPDLSVERPLYELVWTGATLLPDSEGAIDGHLREVGLTFHLLKDVPGLISKNIEKSLKEAFTPLGISDWNSTFWIAHPGGPAILDQVEAKLGLKEEKMRATREV
LSEYGNMSSAC
>gi|13919613|gb|AAK33142.1| chalcone synthase [Fragaria vesca subsp. bracteata]
YPDYYFRITNREHKAELKEKFQRMCDKSMIKKRYMYLTEEILKENPSMCEYMAPSLDARQDMVVVEIPKLGKEAAVKAIKEWGQ
>gi|13925890|gb|AAK49457.1| chalcone synthase [Nicotiana tabacum]

MVTVEEFRRAQCAEGPATVMAIGTATPSNCVDQSTYPDYYFRITNSEHKVELKEKFKRMCEKSMIKKRYMHLTEEILKENPNICAYMAPSLDARQDIVVVEVPKLGKEAAQKAIKEWGQPKSKITHLVFCTTSGVDMPGCDYQLTKLLGLRPSVKRFMMYQQGCFAGGTVLRMAKDLAENNKGARVLVVCSEITAVTFRGPNDTHLDSLVGQALFGDGAAAVIIGSDPIPEVERPLFELVSAAQTLLPDSEGAIDGHLREVGLTFHLLKDVPGLISKNIEKSLVEAFQPLGISDWNSLFWIAHPGGPAILDQVELKLGLKQEKLKATRKVLSNYGNMSSACVLFILDEMRKASAKEGLGTTGEGLEWGVLFGFGPGLTVETVVLHSVAT

3.2 指定字典的键

使用 FASTA 文件代替,用法和上面的相似:
from Bio import SeqIO
handle = open("ls_orchid.fasta")
orchid_dict = SeqIO.to_dict(SeqIO.parse(handle, "fasta"))
handle.close()
print orchid_dict.keys()
这一次,键是:
['gi|2765596|emb|Z78471.1|PDZ78471', 'gi|2765646|emb|Z78521.1|CCZ78521', ...
..., 'gi|2765613|emb|Z78488.1|PTZ78488', 'gi|2765583|emb|Z78458.1|PHZ78458']

当我们在先前的 2.4.1 节分析 FASTA 文件时,你就需要认识这些字符串。假定你更愿意使用其他作为键--像 AC 号。这给了我们一个很好的 SeqIO.to_dict()的选择参数 key_function, 将让你定义你所使用的记录的字典的键。首先,当给出 SeqRecord 对象时,你需要写你自己的函数来得到你想要的键。一般来说,函数细节将依赖于你处理的输入记录的分类。但是对于 orchids,我们仅仅需要使用"|",把标识符分开,然后返回第四个条目:

def get_accession(record) :
""""Given a SeqRecord, return the accession number as a string
e.g. "gi|2765613|emb|Z78488.1|PTZ78488" -> "Z78488.1"
"""

parts = record.id.split("|")
assert len(parts) == 5 and parts[0] == "gi" and parts[2] == "emb"
return parts[3]
这样,我们可以把这个函数送到 SeqIO.to_dict()函数以构建字典:
from Bio import SeqIO
handle = open("ls_orchid.fasta")
orchid_dict
=
SeqIO.to_dict(SeqIO.parse(handle,
"fasta"),
key_function=get_accession)
handle.close()
print orchid_dict.keys()
最后,像预期的那样,新的字典键:
>>> print orchid_dict.keys()
['Z78484.1', 'Z78464.1', 'Z78455.1', 'Z78442.1', 'Z78532.1', 'Z78453.1', ..., 'Z78471.1']
我希望并不是十分复杂!

3.3 使用 SEGUID 来索引一个字典

给出另外一个处理 SeqRecord 对象字典的例子,我们需要使用 SEGUIDchecksum 函数(在 Biopython 1.44 中添加).这是一个最近的 checksum,冲突会很稀少 (也就是说,两个不同的序列使用一个相同的 checksum)在 CRC64checksum 上改进。再次处理 orchids 的 GenBank 文件:
from Bio import SeqIO
from Bio.SeqUtils.CheckSum import seguid
for record in SeqIO.parse(open("ls_orchid.gbk"), "genbank") :
print record.id, seguid(record.seq)
会给出:
Z78533.1 JUEoWn6DPhgZ9nAyowsgtoD9TTo
Z78532.1 MN/s0q9zDoCVEEc+k/IFwCNF2pY
...
Z78439.1 H+JfaShya/4yyAj7IbMqgNkxdxQ

现在,重新调用 Bio.SeqIO.to_dict()函数的 key_function 变量期待一个函数将SeqRecord 变成一个字符串。我们不能直接使用 seguid()函数,因为它将给出一个 Seq 对象(或一个字符串)但是,我们可以使用 python 的 lambda 特性创造一个“一次性”的函数给 Bio.SeqIO.to_dict()代替:
from Bio import SeqIO
from Bio.SeqUtils.CheckSum import seguid
seguid_dict = SeqIO.to_dict(SeqIO.parse(open("ls_orchid.gbk"), "genbank"),lambda
rec : seguid(rec.seq))
record = seguid_dict["MN/s0q9zDoCVEEc+k/IFwCNF2pY"]
print record.id
print record.description
那会检索到记录 Z78532.1,文件中的第二个条目。

4.1 在序列文件格式间转化

在先前的例子中,我们使用了一个 SeqRecord 对象列表作为 Bio.SeqIO.parse()的输入,但是它也接受 SeqRecord iterator,就像我们在 Bio.SeqIO.parse()中所得到的一样—这使得我们很简单的进行文件转化。例如,我们将读取 ls_orchid.gbk文件,然后输出为 FASTA 格式:
from Bio import SeqIO
in_handle = open("ls_orchid.gbk", "r")
out_handle = open("my_example.fasta", "w")
SeqIO.write(SeqIO.parse(in_handle, "genbank"), out_handle, "fasta")
in_handle.close()
out_handle.close()
事实上,你可以在一行中完成,通过关闭文件 handle。 这是一个不好的格
式,但是很简洁:
from Bio import SeqIO
SeqIO.write(SeqIO.parse(open("ls_orchid.gbk"), "genbank"), open("my_example.faa",

"w"), "fasta")

4.2 转化序列文件成它们的反向互补

假如你有一个核酸序列文件,你希望把它转变成包含它们反向互补序列的文件。这次我们需要做些工作来转换我们得到的文件中的 SeqRecords 成适合保存的输出文件。我们将使用 Bio.SeqIO.parse()从一个文件中载入一些核酸序列开始。然后使用 Seq 对象的内置函数.reverse_complement()方法,打印出它们的反向互补。
from Bio import SeqIO
in_handle = open("ls_orchid.gbk")
for record in SeqIO.parse(in_handle, "genbank") :
print record.id
print record.seq.reverse_complement().tostring()
in_handle.close()
现在,如果你想保存这些反向互补序列到一个文件中,我们需要创造SeqRecord 对象。对于此,我想写我们自己的函数会更简洁,我们可以决定如何命名我们的新记录:
from Bio.SeqRecord import SeqRecord
def make_rc_record(record) :
"""Returns a new SeqRecord with the reverse complement sequence"""
rc_rec = SeqRecord(seq = record.seq.reverse_complement(), \
id = "rc_" + record.id, \
name = "rc_" + record.name, \
description = "reverse complement")
return rc_rec
然后,我们可以使用这个来把输入记录转变为反向互补记录以输出。如果你不介意一次将所有的记录保存在内存中,这样的话,python 的 map()函数是一个非常好的方式来解决做这个:
from Bio import SeqIO
in_handle = open("ls_orchid.fasta", "r")
records = map(make_rc_record, SeqIO.parse(in_handle, "fasta"))
in_handle.close()
out_handle = open("rev_comp.fasta", "w")
SeqIO.write(records, out_handle, "fasta")

out_handle.close()

这是一个展现 list comprehension 强大功能的好地方,你可以使用最简单的形式完成冗长的相当的任务:
records = [make_rc_record(rec) for rec in SeqIO.parse(in_handle, "fasta")]
list comprehension 有一个对其内容很好的修饰,你可以添加一个条件语句:
records = [make_rc_record(rec) for rec in SeqIO.parse(in_handle, "fasta") if
len(rec)<700]
这会在内存中创建一个序列长度小于 700 碱基对的反向互补记录。但是,如果你使用 Python 2.4 或更高版本,我们可以使用一个 generator 表达式来做相同的事情。但是这不是在内存中一次性创建所有的记录:
records = (make_rc_record(rec) for rec in SeqIO.parse(in_handle, "fasta") if
len(rec)<700)
如果你喜欢压缩的代码,不介意不严格的文件 handle,我们可以简化这个成
一长行:
from Bio import SeqIO
SeqIO.write((make_rc_record(rec) for rec in \
SeqIO.parse(open("ls_orchid.fasta", "r"), "fasta") if len(rec) < 700), \
open("rev_comp.fasta", "w"), "fasta")
个人观点,我认为以上的代码片段有点太压缩了,下面的代码更易阅读:
from Bio import SeqIO
records = (make_rc_record(rec) for rec in \
SeqIO.parse(open("ls_orchid.fasta", "r"), "fasta") \
if len(rec) < 700)
SeqIO.write(records, open("rev_comp.fasta", "w"), "fasta")
或者,对于 2.3 版本或更老版本:
from Bio import SeqIO
records = [make_rc_record(rec) for rec in \
SeqIO.parse(open("ls_orchid.fasta", "r"), "fasta") \
if len(rec) < 700]
SeqIO.write(records, open("rev_comp.fasta", "w"), "fasta")