Bio.SeqIO包

子模块

模块内容

将输入/输出排序为SeqRecord对象。

Bio.SeqIO还记录在 SeqIO 并在我们的教程中用了整整一章：

输入

主要函数是Bio.SeqIO.parse(.)它接受输入文件句柄(或者在Biopython的最新版本中，文件名作为字符串)和格式化字符串。这将返回一个提供SeqRecord对象的迭代器：

>>> from Bio import SeqIO
>>> for record in SeqIO.parse("Fasta/f002", "fasta"):
...     print("%s %i" % (record.id, len(record)))
gi|1348912|gb|G26680|G26680 633
gi|1348917|gb|G26685|G26685 413
gi|1592936|gb|G29385|G29385 471

请注意，parse()函数将使用其默认设置调用格式的相关解析器。您可能需要更多的控制，在这种情况下，您需要直接创建特定于格式的序列迭代器。

其中一些解析器是低级解析器的包装器，这些解析器为一致的SeqIO接口构建SeqRecord对象。在运行时非常关键的情况下，例如大型FASTA或FASTQ文件，调用这些底层解析器会快得多-在这种情况下，这些返回字符串元组的生成器函数：

>>> from Bio.SeqIO.FastaIO import SimpleFastaParser
>>> from Bio.SeqIO.QualityIO import FastqGeneralIterator

输入-单个记录

如果您希望您的文件包含且仅包含一条记录，则我们提供以下‘helper’函数，该函数将返回单个SeqRecord，或者在没有记录或多条记录时引发异常：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/f001", "fasta")
>>> print("%s %i" % (record.id, len(record)))
gi|3318709|pdb|1A91| 79

当您只需要一条记录(并且会将多条记录视为错误)时，此样式非常有用。例如，在处理细菌基因组或染色体的GenBank文件时，通常只有一个记录。或者，在从Internet下载单个记录时将其与句柄一起使用。

但是，如果您只需要包含多条记录文件中的第一条记录，请在迭代器上使用next()函数：

>>> from Bio import SeqIO
>>> record = next(SeqIO.parse("Fasta/f002", "fasta"))
>>> print("%s %i" % (record.id, len(record)))
gi|1348912|gb|G26680|G26680 633

只要文件包含至少一条记录，上述代码就可以工作。请注意，如果有多条记录，则其余记录将被静默忽略。

输入-多条记录

对于包含多条记录的非隔行扫描文件(如FASTA、GenBank、EMBL)，使用序列迭代器可以节省大量内存(RAM)。隔行扫描文件格式(例如，大多数多对齐文件格式)的益处较小。但是，迭代器只允许您逐个访问记录。

如果您希望按编号随机访问记录，请将其转换为列表：

>>> from Bio import SeqIO
>>> records = list(SeqIO.parse("Fasta/f002", "fasta"))
>>> len(records)
3
>>> print(records[1].id)
gi|1348917|gb|G26685|G26685

如果您希望通过记录ID等键随机访问记录，请将迭代器转换为字典：

>>> from Bio import SeqIO
>>> record_dict = SeqIO.to_dict(SeqIO.parse("Fasta/f002", "fasta"))
>>> len(record_dict)
3
>>> print(len(record_dict["gi|1348917|gb|G26685|G26685"]))
413

但是，使用list()或to_dict()函数会一次将所有记录加载到内存中，因此在非常大的文件上是不可能的。取而代之的是，对于 some 文件格式Bio.SeqIO提供了一种索引方法，可以像字典一样访问任何记录。例如,

>>> from Bio import SeqIO
>>> record_dict = SeqIO.index("Fasta/f002", "fasta")
>>> len(record_dict)
3
>>> print(len(record_dict["gi|1348917|gb|G26685|G26685"]))
413
>>> record_dict.close()

许多(但不是所有)受支持的输入文件格式都可以这样编制索引。例如，“FASTA”、“FASTQ”、“QUAL”，甚至二进制格式“SFF”都可以使用，但是像“Phylip”、“clustriw”和“nexus”这样的对齐格式就不行。

在大多数情况下，您还可以使用SeqIO.index以原始字符串(而不是SeqRecord)的形式从文件中获取记录。例如，这对于从SeqIO不能输出文件格式(例如，纯文本SwissProt格式“Swiss”)的文件中提取记录子集或保持输出与输入100%相同非常重要)。例如,

>>> from Bio import SeqIO
>>> record_dict = SeqIO.index("Fasta/f002", "fasta")
>>> len(record_dict)
3
>>> print(record_dict.get_raw("gi|1348917|gb|G26685|G26685").decode())
>gi|1348917|gb|G26685|G26685 human STS STS_D11734.
CGGAGCCAGCGAGCATATGCTGCATGAGGACCTTTCTATCTTACATTATGGCTGGGAATCTTACTCTTTC
ATCTGATACCTTGTTCAGATTTCAAAATAGTTGTAGCCTTATCCTGGTTTTACAGATGTGAAACTTTCAA
GAGATTTACTGACTTTCCTAGAATAGTTTCTCTACTGGAAACCTGATGCTTTTATAAGCCATTGTGATTA
GGATGACTGTTACAGGCTTAGCTTTGTGTGAAANCCAGTCACCTTTCTCCTAGGTAATGAGTAGTGCTGT
TCATATTACTNTAAGTTCTATAGCATACTTGCNATCCTTTANCCATGCTTATCATANGTACCATTTGAGG
AATTGNTTTGCCCTTTTGGGTTTNTTNTTGGTAAANNNTTCCCGGGTGGGGGNGGTNNNGAAA

>>> print(record_dict["gi|1348917|gb|G26685|G26685"].format("fasta"))
>gi|1348917|gb|G26685|G26685 human STS STS_D11734.
CGGAGCCAGCGAGCATATGCTGCATGAGGACCTTTCTATCTTACATTATGGCTGGGAATC
TTACTCTTTCATCTGATACCTTGTTCAGATTTCAAAATAGTTGTAGCCTTATCCTGGTTT
TACAGATGTGAAACTTTCAAGAGATTTACTGACTTTCCTAGAATAGTTTCTCTACTGGAA
ACCTGATGCTTTTATAAGCCATTGTGATTAGGATGACTGTTACAGGCTTAGCTTTGTGTG
AAANCCAGTCACCTTTCTCCTAGGTAATGAGTAGTGCTGTTCATATTACTNTAAGTTCTA
TAGCATACTTGCNATCCTTTANCCATGCTTATCATANGTACCATTTGAGGAATTGNTTTG
CCCTTTTGGGTTTNTTNTTGGTAAANNNTTCCCGGGTGGGGGNGGTNNNGAAA

>>> record_dict.close()

在这里，原始文件和Biopython将输出的内容在换行方面有所不同。还要注意，get_raw方法将返回一个Bytes对象，因此使用DECODE将其转换为字符串。

还要注意，get_raw方法将保留换行符结尾。此示例FASTQ文件使用Unix样式的结尾(仅限b“n”)，

>>> from Bio import SeqIO
>>> fastq_dict = SeqIO.index("Quality/example.fastq", "fastq")
>>> len(fastq_dict)
3
>>> raw = fastq_dict.get_raw("EAS54_6_R1_2_1_540_792")
>>> raw.count(b"\n")
4
>>> raw.count(b"\r\n")
0
>>> b"\r" in raw
False
>>> len(raw)
78
>>> fastq_dict.close()

下面是相同的文件，但使用的是DOS/Windows换行符(b“rn”)，

>>> from Bio import SeqIO
>>> fastq_dict = SeqIO.index("Quality/example_dos.fastq", "fastq")
>>> len(fastq_dict)
3
>>> raw = fastq_dict.get_raw("EAS54_6_R1_2_1_540_792")
>>> raw.count(b"\n")
4
>>> raw.count(b"\r\n")
4
>>> b"\r\n" in raw
True
>>> len(raw)
82
>>> fastq_dict.close()

因为它为每个新行使用两个字节，所以该文件比Unix等效项要长，只有一个字节。

输入对齐

可以使用Bio.AlignIO将路线文件作为路线对象读入。或者，通过Bio.SeqIO读取路线文件格式将为您提供每条路线的每一行的SeqRecord：

>>> from Bio import SeqIO
>>> for record in SeqIO.parse("Clustalw/hedgehog.aln", "clustal"):
...     print("%s %i" % (record.id, len(record)))
gi|167877390|gb|EDS40773.1| 447
gi|167234445|ref|NP_001107837. 447
gi|74100009|gb|AAZ99217.1| 447
gi|13990994|dbj|BAA33523.2| 447
gi|56122354|gb|AAV74328.1| 447

输出

使用函数Bio.SeqIO.write(.)，该函数接受完整的SeqRecord对象集(作为列表或迭代器)、输出文件句柄(或在最新版本的Biopython中作为字符串的输出文件名)，当然还有文件格式：：

from Bio import SeqIO
records = ...
SeqIO.write(records, "example.faa", "fasta")

或者，使用句柄：：

from Bio import SeqIO
records = ...
with open("example.faa", "w") as handle:
  SeqIO.write(records, handle, "fasta")

您需要调用此函数一次(包含所有记录)，如果使用句柄，请确保将其关闭以将数据刷新到硬盘。

输出-高级

对单个文件多次调用write()的效果会因文件格式的不同而有所不同，除非您有充分的理由这样做，否则最好避免这样做。

如果给出一个文件名，那么每次调用write()时，现有文件都会被覆盖。对于顺序文件格式(如FASTA、GENBANK)，每个“记录挡路”都有一个顺序。对于这些文件，通过重用同一句柄多次调用write()可能是安全的。

然而，对于某些比对格式(例如PHYLIP、CLUSTAL、斯德哥尔摩)尝试这种方式将具有将多个多序列比对串联在一起的效果。这样的文件是由Phylip程序套件创建的，用于引导分析，但是通过Bio.AlignIO来完成这项工作会更清楚。

更糟糕的是，许多文件格式都有显式的页眉和/或页脚结构(例如，任何XML格式，以及大多数二进制文件格式，如SFF)。在这里，多次调用write()将导致文件无效。

转换

Bio.SeqIO.Convert(.)函数为简单的文件格式转换提供了一个简单的接口。此外，它可能使用特定于文件格式的优化，因此这也应该是最快的方式。

不过，通常可以将Bio.SeqIO.parse(.)使用Bio.SeqIO.write(.)序列文件转换函数。使用生成器表达式或生成器函数提供了一种内存高效的方式，可以将过滤或其他额外操作作为过程的一部分来执行。

文件格式

指定文件格式时，请使用小写字符串。Bio.AlignIO中也使用相同的格式名称，包括以下内容：

  • ABI应用生物系统的测序轨迹格式

  • ABI-TRIM-与“ABI”相同，但使用Mott算法进行质量修剪

  • ACE-从ACE部件文件中读取重叠群序列。

  • CIF-ATOM-使用Bio.PDB.MMCIFParser根据原子坐标确定结构中出现的(部分)蛋白质序列。

  • cif-seqres-读取大分子晶体信息文件(MmCIF)文件以确定由_pdbx_poly_seq_Scheme记录定义的完整蛋白质序列。

  • embl-EMBL平面文件格式。在内部使用Bio.GenBank。

  • FASTA-通用序列文件格式，其中每条记录都以标识符行开头，以“>”字符开头，后跟序列行。

  • FASTA-2行-更严格地解释FASTA格式，每条记录只使用两行(没有换行)。

  • FASTQ-Sanger使用的一种“FASTA LIKE”格式，它还存储PHRED序列质量值(ASCII偏移量为33)。

  • FASTQ-Sanger-“FASTQ”的别名，用于与BioPerl和Emoss保持一致

  • FASTQ-Solexa-FASTQ格式的原始Solexa/Illumnia变体，它使用64的ASCII偏移量对Solexa质量分数(非Phred质量分数)进行编码。

  • FASTQ-Illumina-Solexa/Illumina 1.3到1.7版本的FASTQ格式，它使用64(而不是33)的ASCII偏移量对PHRED质量分数进行编码。注从Casava管道的1.8版开始，Illumina将使用标准Sanger编码生成FASTQ文件。

  • GCK-基因构建试剂盒的格式。

  • GenBank-GenBank或GenPept平面文件格式。

  • GB-“GenBank”的别名，与NCBI Entrez实用程序保持一致

  • IG-IntelliGenetics文件格式，显然与MASE对齐格式相同。

  • IMGT-来自IMGT的类似EMBL的格式，其中要素表更多地缩进，以允许更长的要素类型。

  • NIB-UCSC用于核苷酸序列的NIB文件格式，它使用一个半字节(4位)来表示每个核苷酸，并在一个字节中存储两个核苷酸。

  • pdb-seqres-读取蛋白质数据库(PDB)文件以确定标题中显示的完整蛋白质序列(无相关性)。

  • PDB-ATOM-基于文件的原子坐标部分，使用Bio.PDB确定结构中出现的(部分)蛋白质序列(Bio.PDB需要NumPy)。

  • PHD-来自PRED的输出，由PHRAP和CONSED用于输入。

  • PIR-国家生物医学研究基金会(NBRF)为蛋白质信息资源(PIR)数据库引入的一种“Fasta Like”格式，现在是UniProt的一部分。

  • seqxml-SeqXML，Schmitt等人(2011)中描述的简单XML格式。

  • SFF-标准流程图格式(SFF)，来自罗氏454的典型输出。

  • SFF-TRIM-应用给定修剪的标准流程图格式(SFF)。

  • SnapGene-SnapGene的原生格式。

  • 瑞士-纯文本瑞士-Prot(又名UniProt格式)。

  • 制表符-简单的两列制表符分隔的序列文件，其中每行保存一条记录的标识符和序列。例如，Aligent的eArray软件在将微阵列探针保存在最小的制表符分隔文本文件中时会使用此选项。

  • QUAL-一种“FASTA LIKE”格式，包含测序DNA的Phred质量值，但没有实际序列(通常在单独的FASTA文件中提供)。

  • UniProt-XML-UniProt XML格式(取代我们称之为“Swiss”的SwissProt纯文本格式)

  • XDNA-DNA Strider和SerialCloner的本机格式。

请注意，虽然Bio.SeqIO可以读取上述所有文件格式，但它不能写入所有文件格式。

您还可以使用Bio.AlignIO支持的任何文件格式，例如“nexus”、“Phylip”和“斯德哥尔摩”，这样您就可以访问组成每个比对的单个序列作为SeqRecords。

Bio.SeqIO.write(sequences, handle, format)

将完整的序列集写入文件。

参数：

  • 序列-SeqRecord对象的列表(或迭代器)，或单个SeqRecord。

  • Handle-要写入的文件句柄对象，或字符串形式的文件名。

  • 格式-描述要写入的文件格式的小写字符串。

注如果提供文件句柄，您的代码应该在调用此函数后关闭该句柄(以确保将数据刷新到磁盘)。

返回写入的记录数(整数形式)。

Bio.SeqIO.parse(handle, format, alphabet=None)

将序列文件转换为返回SeqRecords的迭代器。

参数：

  • Handle-文件的句柄，或字符串形式的文件名(请注意，旧版本的Biopython只接受句柄)。

  • 格式-描述文件格式的小写字符串。

  • 字母表-不再使用，应为无。

典型用法是打开要读入的文件，然后循环遍历记录：

>>> from Bio import SeqIO
>>> filename = "Fasta/sweetpea.nu"
>>> for record in SeqIO.parse(filename, "fasta"):
...    print("ID %s" % record.id)
...    print("Sequence length %i" % len(record))
ID gi|3176602|gb|U78617.1|LOU78617
Sequence length 309

对于延迟加载的文件格式(如两位)，其文件内容仅按需读取，请确保在提取序列数据时文件保持打开状态。

如果您有一个包含文件内容的字符串‘data’，则必须首先将其转换为句柄才能对其进行解析：

>>> data = ">Alpha\nACCGGATGTA\n>Beta\nAGGCTCGGTTA\n"
>>> from Bio import SeqIO
>>> from io import StringIO
>>> for record in SeqIO.parse(StringIO(data), "fasta"):
...     print("%s %s" % (record.id, record.seq))
Alpha ACCGGATGTA
Beta AGGCTCGGTTA

使用Bio.SeqIO.read(.)函数，当您只需要一条记录时。

Bio.SeqIO.read(handle, format, alphabet=None)

将序列文件转换为单个SeqRecord。

参数：

  • Handle-文件的句柄，或字符串形式的文件名(请注意，旧版本的Biopython只接受句柄)。

  • 格式-描述文件格式的字符串。

  • 字母表-不再使用，应为无。

此函数用于解析正好包含一条记录的序列文件。例如，读取GenBank文件：

>>> from Bio import SeqIO
>>> record = SeqIO.read("GenBank/arab1.gb", "genbank")
>>> print("ID %s" % record.id)
ID AC007323.5
>>> print("Sequence length %i" % len(record))
Sequence length 86436

如果句柄不包含任何记录，或包含多条记录，则会引发异常。例如：

>>> from Bio import SeqIO
>>> record = SeqIO.read("GenBank/cor6_6.gb", "genbank")
Traceback (most recent call last):
    ...
ValueError: More than one record found in handle

但是，如果您想要包含多条记录的文件中的第一条记录，则此函数将引发异常(如上面的示例所示)。请改用：

>>> from Bio import SeqIO
>>> record = next(SeqIO.parse("GenBank/cor6_6.gb", "genbank"))
>>> print("First record's ID %s" % record.id)
First record's ID X55053.1

如果要从句柄读取多条记录，请使用Bio.SeqIO.parse(Handle，Format)函数。

Bio.SeqIO.to_dict(sequences, key_function=None)

将序列迭代器或列表转换为字典。

参数：

  • 序列-返回SeqRecord对象的迭代器，或者仅仅是SeqRecord对象的列表。

  • key_function-可选的回调函数，当给定SeqRecord时，它应该返回字典的唯一键。

例如key_function=lambda rec：rec.name或key_function=lambda rec：rec.description ption.plit() [0]

如果省略key_function，则使用record.id，前提是返回的记录对象是具有唯一id的SeqRecords。

如果存在重复的键，则会引发错误。

从Python3.7开始，默认的DICT类保持键顺序，这意味着该字典将反映提供给它的记录的顺序。对于CPython和PyPy，这已经在Python3.6中实现了，因此您可以始终有效地假设记录顺序是保留的。

示例用法，默认使用record.id作为键：

>>> from Bio import SeqIO
>>> filename = "GenBank/cor6_6.gb"
>>> format = "genbank"
>>> id_dict = SeqIO.to_dict(SeqIO.parse(filename, format))
>>> print(list(id_dict))
['X55053.1', 'X62281.1', 'M81224.1', 'AJ237582.1', 'L31939.1', 'AF297471.1']
>>> print(id_dict["L31939.1"].description)
Brassica rapa (clone bif72) kin mRNA, complete cds

一个更复杂的示例，使用key_function参数以使用序列校验和作为字典键：

>>> from Bio import SeqIO
>>> from Bio.SeqUtils.CheckSum import seguid
>>> filename = "GenBank/cor6_6.gb"
>>> format = "genbank"
>>> seguid_dict = SeqIO.to_dict(SeqIO.parse(filename, format),
...               key_function = lambda rec : seguid(rec.seq))
>>> for key, record in sorted(seguid_dict.items()):
...     print("%s %s" % (key, record.id))
/wQvmrl87QWcm9llO4/efg23Vgg AJ237582.1
BUg6YxXSKWEcFFH0L08JzaLGhQs L31939.1
SabZaA4V2eLE9/2Fm5FnyYy07J4 X55053.1
TtWsXo45S3ZclIBy4X/WJc39+CY M81224.1
l7gjJFE6W/S1jJn5+1ASrUKW/FA X62281.1
uVEYeAQSV5EDQOnFoeMmVea+Oow AF297471.1

这种方法不适合非常大的序列集，因为所有的SeqRecord对象都保存在内存中。相反，可以考虑使用Bio.SeqIO.index()函数(如果它支持您的特定文件格式)。

从Python3.6开始，默认的DICT类保持键顺序，这意味着此字典将反映提供给它的记录顺序。从Biopython1.72开始，在旧版本的Python上，我们显式使用OrderedDict，这样您就可以始终假定记录顺序是保留的。

Bio.SeqIO.index(filename, format, alphabet=None, key_function=None)

索引序列文件并返回一个类似字典的对象。

参数：

  • FileName-给出要编制索引的文件名称的字符串

  • Format-描述文件格式的小写字符串

  • 字母表-不再使用，保留为无

  • key_function-可选的回调函数，当给定SeqRecord标识符字符串时，它应该返回字典的唯一键。

此索引函数将返回一个类似字典的对象，给出SeqRecord对象作为值。

从Biopython1.69开始，这将在迭代条目时保留文件中记录的顺序。

>>> from Bio import SeqIO
>>> records = SeqIO.index("Quality/example.fastq", "fastq")
>>> len(records)
3
>>> list(records)  # make a list of the keys
['EAS54_6_R1_2_1_413_324', 'EAS54_6_R1_2_1_540_792', 'EAS54_6_R1_2_1_443_348']
>>> print(records["EAS54_6_R1_2_1_540_792"].format("fasta"))
>EAS54_6_R1_2_1_540_792
TTGGCAGGCCAAGGCCGATGGATCA

>>> "EAS54_6_R1_2_1_540_792" in records
True
>>> print(records.get("Missing", None))
None
>>> records.close()

如果文件是BGZF压缩的，则会自动检测到这一点。不支持普通GZIP文件：

>>> from Bio import SeqIO
>>> records = SeqIO.index("Quality/example.fastq.bgz", "fastq")
>>> len(records)
3
>>> print(records["EAS54_6_R1_2_1_540_792"].seq)
TTGGCAGGCCAAGGCCGATGGATCA
>>> records.close()

当您调用index函数时，它将扫描整个文件，并注明每条记录的位置。当您通过DICTIONARY方法访问特定记录时，代码将跳转到文件的适当部分，然后将该部分解析为SeqRecord。

请注意，并不是Bio.SeqIO支持的所有输入格式都可以与此索引函数一起使用。它仅设计用于顺序文件格式(例如，“FASTA”、“GB”、“FASTQ”)，而不适用于任何隔行扫描的文件格式(例如，诸如“CLUSTAL”的对齐格式)。

对于小文件，使用内存中的Python字典可能更有效，例如

>>> from Bio import SeqIO
>>> records = SeqIO.to_dict(SeqIO.parse("Quality/example.fastq", "fastq"))
>>> len(records)
3
>>> list(records)  # make a list of the keys
['EAS54_6_R1_2_1_413_324', 'EAS54_6_R1_2_1_540_792', 'EAS54_6_R1_2_1_443_348']
>>> print(records["EAS54_6_R1_2_1_540_792"].format("fasta"))
>EAS54_6_R1_2_1_540_792
TTGGCAGGCCAAGGCCGATGGATCA

与to_dict()函数一样，默认情况下使用每条记录的id字符串作为键。您可以指定一个回调函数将此(记录标识符字符串)转换为您首选的键。例如：

>>> from Bio import SeqIO
>>> def make_tuple(identifier):
...     parts = identifier.split("_")
...     return int(parts[-2]), int(parts[-1])
>>> records = SeqIO.index("Quality/example.fastq", "fastq",
...                       key_function=make_tuple)
>>> len(records)
3
>>> list(records)  # make a list of the keys
[(413, 324), (540, 792), (443, 348)]
>>> print(records[(540, 792)].format("fasta"))
>EAS54_6_R1_2_1_540_792
TTGGCAGGCCAAGGCCGATGGATCA

>>> (540, 792) in records
True
>>> "EAS54_6_R1_2_1_540_792" in records
False
>>> print(records.get("Missing", None))
None
>>> records.close()

另一个常见用例是索引NCBI样式的FASTA文件，其中您可能希望从FASTA标识符中提取GI编号以用作字典键。

注意，与to_dict()函数不同，这里的key_function没有获得用于生成密钥的完整SeqRecord。这样做会造成严重的性能损失，因为它需要在构建索引时完全解析文件。目前，这通常是可以避免的。

另请参阅：Bio.SeqIO.index_db()和Bio.SeqIO.to_dict()

Bio.SeqIO.index_db(index_filename, filenames=None, format=None, alphabet=None, key_function=None)

索引几个序列文件并返回一个类似字典的对象。

索引存储在SQLite数据库中，而不是内存中(如Bio.SeqIO.index(.)函数)。

参数：

  • index_filename-存储SQLite索引的位置

  • 文件名-指定要索引的文件的字符串列表，或者在索引单个文件时，可以将其作为字符串给出。(如果重新加载现有索引，则可选，但必须匹配)

  • Format-描述文件格式的小写字符串(如果重新加载现有索引，则可选，但必须匹配)

  • 字母表-不再使用，保留为无。

  • key_function-可选的回调函数，当给定SeqRecord标识符字符串时，它应该返回字典的唯一键。

此索引函数将返回一个类似字典的对象，并将SeqRecord对象作为值提供：

>>> from Bio import SeqIO
>>> files = ["GenBank/NC_000932.faa", "GenBank/NC_005816.faa"]
>>> def get_gi(name):
...     parts = name.split("|")
...     i = parts.index("gi")
...     assert i != -1
...     return parts[i+1]
>>> idx_name = ":memory:" #use an in memory SQLite DB for this test
>>> records = SeqIO.index_db(idx_name, files, "fasta", key_function=get_gi)
>>> len(records)
95
>>> records["7525076"].description
'gi|7525076|ref|NP_051101.1| Ycf2 [Arabidopsis thaliana]'
>>> records["45478717"].description
'gi|45478717|ref|NP_995572.1| pesticin [Yersinia pestis biovar Microtus str. 91001]'
>>> records.close()

在本例中，这两个文件分别包含85条和10条记录。

支持BGZF压缩文件，并自动检测。不支持普通GZIP压缩文件。

另请参见：Bio.SeqIO.index()和Bio.SeqIO.to_dict()，以及用于构建文件列表的Python模块glob。

Bio.SeqIO.convert(in_file, in_format, out_file, out_format, molecule_type=None)

在两种序列文件格式之间转换，返回记录数。

参数：

  • in_file-输入句柄或文件名

  • in_format-输入文件格式，小写字符串

  • OUT_FILE-输出句柄或文件名

  • OUT_FORMAT-输出文件格式，小写字符串

  • MELEGLER_TYPE-要应用的可选分子类型，包含“DNA”、“RNA”或“Protein”的字符串。

NOTE -如果您提供输出文件名，它将被打开，这将在没有警告的情况下覆盖任何现有文件。

这里的想法是，在这样做的同时将会奏效：

from Bio import SeqIO
records = SeqIO.parse(in_handle, in_format)
count = SeqIO.write(records, out_handle, out_format)

写成：：会更短

from Bio import SeqIO
count = SeqIO.convert(in_handle, in_format, out_handle, out_format)

此外，Bio.SeqIO.Convert对于某些转换速度更快，因为它可以进行一些优化。

例如，从文件名到句柄：

>>> from Bio import SeqIO
>>> from io import StringIO
>>> handle = StringIO("")
>>> SeqIO.convert("Quality/example.fastq", "fastq", handle, "fasta")
3
>>> print(handle.getvalue())
>EAS54_6_R1_2_1_413_324
CCCTTCTTGTCTTCAGCGTTTCTCC
>EAS54_6_R1_2_1_540_792
TTGGCAGGCCAAGGCCGATGGATCA
>EAS54_6_R1_2_1_443_348
GTTGCTTCTGGCGTGGGTGGGGGGG

注意当解析器无法确定分子类型时，某些格式(如SeqXML)要求您指定分子类型：

>>> from Bio import SeqIO
>>> from io import BytesIO
>>> handle = BytesIO()
>>> SeqIO.convert("Quality/example.fastq", "fastq", handle, "seqxml", "DNA")
3