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() 函数将使用其默认设置调用与格式相关的解析器。你可能需要更多控制，在这种情况下，你需要直接创建一个特定格式的序列迭代器。

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

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

输入 - 单个记录

如果你的文件预计只包含一个记录，那么我们提供以下“辅助”函数，它将返回一个 SeqRecord，或者在没有记录或超过一个记录的情况下引发异常

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

此样式在你的预期结果仅包含一条记录（并将多条记录视为错误）时很有用。例如，在处理细菌基因组或染色体的 GenBank 文件时，通常只有一条记录。或者，在从互联网下载单个记录时，可以使用此样式。

但是，如果你只想从包含多个记录的文件中获取第一条记录，请对迭代器使用 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() 函数会一次将所有记录加载到内存中，因此对于非常大的文件来说是不可能的。相反，对于某些文件格式，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()

这是同一个文件，但使用 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、stockholm）这样做会导致将多个多序列比对串联在一起。此类文件由 PHYLIP 程序套件用于引导分析创建，但通过 Bio.AlignIO 来执行此操作会更清晰。

更糟糕的是，许多文件格式都有显式的头部和/或尾部结构（例如，任何 XMl 格式以及大多数二进制文件格式，如 SFF）。在这种情况下，多次调用 write() 将导致无效文件。

转换

Bio.SeqIO.convert(…) 函数提供了一个简单易用的界面，用于执行简单的文件格式转换。此外，它可以使用特定于文件格式的优化，因此这也应该是最快的转换方式。

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

文件格式

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

  • abi - Applied Biosystem 的测序轨迹格式

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

  • ace - 从 ACE 组装文件中读取重叠群序列。

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

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

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

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

  • fasta-2line - 对 FASTA 格式的严格解释，每条记录使用正好两行（不换行）。

  • fastq - 由 Sanger 使用的一种“FASTA 类”格式，它还存储 PHRED 序列质量值（ASCII 偏移量为 33）。

  • fastq-sanger - 与 BioPerl 和 EMBOSS 保持一致的“fastq”别名

  • fastq-solexa - FASTQ 格式的原始 Solexa/Illumnia 变体，它使用 ASCII 偏移量为 64 对 Solexa 质量分数进行编码（不是 PHRED 质量分数）。请注意，从 CASAVA 管道的版本 1.8 开始，Illumina 将使用标准 Sanger 编码生成 FASTQ 文件。

  • fastq-illumina - FASTQ 格式的 Solexa/Illumina 1.3 到 1.7 变体，它使用 ASCII 偏移量为 64（不是 33）对 PHRED 质量分数进行编码。请注意，从 CASAVA 管道的版本 1.8 开始，Illumina 将使用标准 Sanger 编码生成 FASTQ 文件。

  • gck - Gene Construction Kit 的格式。

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

  • gb - 与 NCBI Entrez 工具保持一致的“genbank”别名

  • gfa1 - 图形片段组装版本 1.x。仅解析片段行，忽略所有连接信息。

  • gfa2 - 图形片段组装版本 2.0。仅解析片段行，忽略所有连接信息。

  • ig - IntelliGenetics 文件格式，似乎与 MASE 比对格式相同。

  • imgt - 来自 IMGT 的一种类似 EMBL 的格式，其中特征表缩进更多，以允许更长的特征类型。

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

  • pdb-seqres - 读取蛋白质数据库 (PDB) 文件以确定其标头中出现的完整蛋白质序列（没有依赖项）。

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

  • phd - PHRED 的输出，用于 PHRAP 和 CONSED 的输入。

  • pir - 由国家生物医学研究基金会 (NBRF) 为蛋白质信息资源 (PIR) 数据库（现为 UniProt 的一部分）引入的一种“FASTA 类”格式。

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

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

  • sff-trim - 标准流图格式 (SFF)，应用了给定的修剪。

  • snapgene - SnapGene 的原生格式。

  • swiss - 纯文本 Swiss-Prot 又名 UniProt 格式。

  • tab - 简单两列制表符分隔的序列文件，其中每行都包含记录的标识符和序列。例如，当以最小的制表符分隔的文本文件形式保存微阵列探针时，Aligent 的 eArray 软件会使用此格式。

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

  • uniprot-xml - UniProt XML 格式（替换我们称为“swiss”的 SwissProt 纯文本格式）

  • 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

将一组完整的序列写入文件。

参数

  • sequences - SeqRecord 对象的列表（或迭代器），或单个 SeqRecord。

  • handle - 要写入的文件句柄对象，或作为字符串的文件名。

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

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

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

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

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

参数

  • handle - 文件的句柄，或作为字符串的文件名（注意，Biopython 的较早版本只接受句柄）。

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

  • alphabet - 现在不再使用，应为 None。

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

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

参数

  • handle - 文件的句柄，或作为字符串的文件名（注意，Biopython 的较早版本只接受句柄）。

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

  • alphabet - 现在不再使用，应为 None。

此函数用于解析仅包含一条记录的序列文件。例如，读取 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)

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

参数

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

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

例如，key_function = lambda rec : rec.name 或 key_function = lambda rec : rec.description.split()[0]

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

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

从 Python 3.7 开始，默认的字典类保留键的顺序，这意味着这个字典将反映给它的记录顺序。对于 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_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() 函数（如果它支持您的特定文件格式）。

此字典将反映给它的记录顺序。

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

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

参数

  • filename - 给定要索引的文件名的字符串

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

  • alphabet - 不再使用，保留为 None

  • key_function - 可选的回调函数，当给定一个 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()

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

请注意，并非所有 Bio.SeqIO 支持的输入格式都可以在此 index 函数中使用。它被设计为仅与顺序文件格式（例如“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 索引的位置

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

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

  • alphabet - 不再使用，保留为 None。

  • 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 - 输出文件格式，小写字符串

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

注意 - 如果您提供输出文件名，它将被打开，这将覆盖任何现有文件，不会发出警告。

这里的想法是，虽然这样做会奏效

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