Bio.SeqIO包

子模块

模块内容

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

Bio.SeqIO也记录在 SeqIO 以及我们教程中的一整章：

HTML Tutorial _

PDF Tutorial _

输入

主要功能是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

当您只期望单个记录（并且会将多个记录视为错误）时，这种风格很有用。例如，当处理细菌基因组或染色体的基因库文件时，通常只有一条记录。或者，在从互联网下载单个记录时，使用此选项和手柄一起使用。

然而，如果您只是想要包含多个记录的文件中的第一个记录，请在迭代器上使用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、Gene Bank、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”、“clustalw”和“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方法将返回字节对象，因此使用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()

这是相同的文件，但使用了IOS/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. writer（.）函数，它采用一组完整的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")

您需要调用此函数一次（包含您的所有记录），如果使用手柄，请确保关闭它以将数据刷新到硬盘。

输出-高级

对单个文件多次调用add（）的影响会因文件格式而异，并且最好避免这样做，除非您有充分的理由这样做。

如果你给出一个文件名，那么每次你调用write（）时，现有的文件都会被覆盖。对于顺序文件格式（例如fasta，genbank），每个“记录块”保存一个序列。对于这些文件，通过重用同一个句柄多次调用write（）可能是安全的。

然而，对于某些比对格式（例如phyllip、clustal、stockholm）尝试这样做会产生将几个多序列比对连接在一起的效果。此类文件是由PHYLIP程序套件创建的，用于引导分析，但更清楚的是通过Bio.AlignIO来完成这一操作。

更糟糕的是，许多文件格式都具有显式的头和/或页脚结构（例如任何XM 1格式，以及大多数二进制文件格式，例如SFF）。这里多次调用writing（）将导致文件无效。

转换

Bio.SeqIO.convert（.）该功能提供简单的界面，用于简单的文件格式转换。此外，它可能会使用特定于文件格式的优化，因此这也应该是最快的方法。

但是，一般来说，您可以将Bio.SeqIO.parse（.）函数与Bio.SeqIO.write（.）用于序列文件转换的函数。使用生成器表达式或生成器函数提供了一种高效的内存方式来执行过滤或其他额外操作作为过程的一部分。

文件格式

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

ABI - 应用生物系统公司的测序追踪格式

abi-trim -与“abi”相同，但使用Mott算法进行质量修剪

Ace - 从ACE程序集文件中读取重叠群序列。

cif-atom -使用Bio.PDB.MMCIFParser根据原子坐标确定结构中出现的（部分）蛋白质序列。

cif-seqres -读取大分子晶体信息文件（mmCIF）文件，以确定由_pdbx_poly_seq_scheme记录定义的完整蛋白质序列。

EMBL - EmbL平面文件格式。内部使用Bio. Gene。

fasta - 通用序列文件格式，其中每条记录都以“>”字符开始的标识符行开始，后面是序列行。

fasta-2行-对FASTA格式进行更详细的解释，每个记录恰好使用两行（无行绕行）。

fastq - Sanger使用的“类似FASTA”格式，还存储PHRED序列质量值（ASC偏差为33）。

fastq-sanger -“fastq”的别名，用于与BioPerl和BOSS保持一致

fastq-solexa -FASTQ格式的原始Solexa/Illumnia变体，其编码Solexa质量分数（而不是PHRED质量分数），并具有64的ASC偏差。

fastq-illumina - Solexa/Illumina FASTQ格式的1.3至1.7变体，其编码PHRED质量分数，并具有64（而不是33）的ASC偏差。请注意，从CASAVA管道的1.8版本起，Illumina将使用标准Sanger编码生成FASTQ文件。

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

genbank -genBank或GenPept平面文件格式。

GB - “genbank”的别名，以与NCBI Deliverz Utilities保持一致

gfa 1 - 图形片段汇编v版本1.x。仅分析段线，并且忽略所有链接信息。

gfa 2 - 图形片段装配2.0版。仅分析段线，并且忽略所有链接信息。

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

IMGT - 来自IMGT的一种类似MBE的格式，其中要素表更加凹陷，以允许更长的要素类型。

笔尖 - UCSC的核苷序列nib文件格式，使用一个半字节（4位）来代表每个核苷酸，并在一个字节中存储两个核苷酸。

pdb-seqres -读取蛋白质数据库（DBC）文件以确定标题中出现的完整蛋白质序列（无依赖性）。

pdb-atom -使用Bio. DBC根据文件的原子坐标部分确定结构中出现的（部分）蛋白质序列（Bio. DBC需要NumPy）。

博士 - PHRED的输出，由PHRAP和CONMED用作输入。

PIR - 美国国家生物医学研究基金会（NBRF）为蛋白质信息资源（PIR）数据库引入的“类似FASTA”格式，该数据库现已成为UniProt的一部分。

seqhtml-SeqML，Schmitt et al（2011）中描述的简单ML格式。

SFF - 标准流程图格式（SFF），Roche 454的典型输出。

sff-trim -应用给定修剪的标准流图格式（SFF）。

Snapgene - SnapGene的原生格式。

瑞士 - 纯文本Swiss-Prot又名UniProt格式。

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

qual - 一种“类似FASTA”的格式，保存来自测序DNA的PHRED质量值，但没有实际序列（通常在单独的FASTA文件中提供）。

uniprot-html-UniProt HTML格式（SwissProt纯文本格式的替代品，我们称之为“swiss”）

xdna - DNA Strider和SerialCloner的原生格式。

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

您还可以使用Bio.AlignIO支持的任何文件格式，例如“nexus”、“phylip”和“stockholm”，这使您可以访问组成每个比对的各个序列作为SeqRecords。

Bio.SeqIO.write(sequences: Iterable[SeqRecord] | SeqRecord, handle: IO[str] | PathLike | str | bytes, format: str) → int

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

论点：

序列-SeqRecord对象的列表（或迭代器），或单个SeqRecord。
手柄 - 要写入的文件句柄对象，或字符串形式的文件名。
格式 - 描述要写入的文件格式的大写字符串。

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

返回写入的记录数（作为一个整数）。

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

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

论点：

手柄 - 文件的句柄，或字符串形式的文件名
格式 - 描述文件格式的大写字符串。
字母表-不再使用，应为无。

典型用法，打开一个要读入的文件，并循环遍历记录：

>>> 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

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

如果您有一个包含文件内容的字符串“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。

论点：

手柄 - 文件的手柄，或字符串形式的文件名（请注意，Biopython的旧版本仅采用了手柄）。
格式 - 描述文件格式的字符串。
字母表-不再使用，应为无。

该功能用于解析恰好包含一条记录的序列文件。例如，读取基因库文件：

>>> 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，form）函数。

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

将序列迭代器或列表变成字典。

论点：

序列-返回SeqRecord对象的迭代器，或者简单地返回SeqRecord对象列表。
key_index-可选的回调函数，当给定SeqRecord时，它应该返回字典的唯一键。

例如，key_function = lambda rec：rec.name或key_function = lambda rec：rec.description.split（） [0]

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

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

自Python 3.7以来，默认的dict类会维护键顺序，这意味着该字典将反映赋予它的记录顺序。对于CPython和PyPy，这已经在Python 3.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_index参数以使用序列检验和作为字典键：

>>> 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（）函数（如果它支持您的特定文件格式）。

该词典将反映为其提供的记录的顺序。

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

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

论点：

文件名-给出要索引的文件名称的字符串
格式 - 描述文件格式的大写字符串
字母表-不再使用，保留为无
key_index-可选的回调函数，当给定SeqRecord标识符字符串时，它应该返回字典的唯一键。

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

从Biopython 1.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()

当您调用索引函数时，它将扫描该文件，并注明每个记录的位置。当您通过字典方法访问特定记录时，代码将跳转到文件的适当部分，然后将该部分解析为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_函数不会获得完整的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_file-存储SQLite索引的位置
文件名-指定要索引的文件的字符串列表，或者当索引单个文件时，可以将其作为字符串给出。（如果重新加载现有索引，则可选，但必须匹配）
格式 - 描述文件格式的大写字符串（如果重新加载现有索引，则可选，但必须匹配）
字母表-不再使用，保留为无。
key_index-可选的回调函数，当给定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条记录。

支持BGZR压缩文件并自动检测。不支持普通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_form-输出文件格式，大写字符串
molecule_ype-可选应用的分子类型，字符串包含“DNA”、“RNA”或“蛋白质”。

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

请注意，当解析器无法确定分子类型时，SeqML等某些格式要求您指定分子类型：

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