Bio.SeqIO. Quality IO模块
Bio.SeqIO支持FASTQ和QUAL文件格式。
请注意，您需要通过Bio.SeqIO接口使用此代码，如下所示。
Wellcome Trust Sanger Institute经常使用FASTQ文件格式来捆绑FASTA序列及其PHRED质量数据（0到90之间的整数）。 不是使用单个FASTQ文件，而是使用通常成对的FASTA和QUAL文件，分别包含序列和质量信息。
PHRED软件读取DNA测序跟踪文件，调用碱基，并使用错误概率的对数转换Q = -10 log 10（Pe）将非负质量值分配给每个调用的碱基，例如：
Pe = 1.0, Q = 0
Pe = 0.1, Q = 10
Pe = 0.01, Q = 20
...
Pe = 0.00000001, Q = 80
Pe = 0.000000001, Q = 90
在典型的原始序列读取中，PHRED质量值a将从0到40。在QUAL格式中，这些质量值以类似FASTA文件格式的空格分隔文本形式保存。 在FASTQ格式中，每个质量值都使用chr（Q+33）用单个ASCI字符编码，这意味着零映射到字符“！例如80映射到“q”。 对于Sanger FASTQ标准，PHRED评分的允许范围为0至93（含0至93）。然后，序列和质量以类似FASTA的格式成对存储。
不幸的是，没有描述FASTQ文件格式的官方文件，更糟糕的是，存在几个相关但不同的变体。欲了解更多详细信息，请阅读此开放获取出版物：：
The Sanger FASTQ file format for sequences with quality scores, and the
Solexa/Illumina FASTQ variants.
P.J.A.Cock (Biopython), C.J.Fields (BioPerl), N.Goto (BioRuby),
M.L.Heuer (BioJava) and P.M. Rice (EMBOSS).
Nucleic Acids Research 2010 38(6):1767-1771
https://doi.org/10.1093/nar/gkp1137
好消息是，罗氏454测序仪可以以QUAL格式输出文件，并且他们明智地使用了像Sanger这样的PHBEP风格的分数。 将一对FASTA和QUAL文件转换为Sanger风格的FASTQ文件很容易。要从Roche 454 SFF二进制文件中提取QUAL文件，请使用Roche离仪器命令行工具“sffinfo”和-q或-qual参数。 您可以使用-s或-seq参数提取匹配的FASTA文件。
坏消息是Solexa/Illumina的做法有所不同--他们有自己的评分系统和自己的FASTQ格式不兼容版本。Solexa/Illumina质量评分使用Q = - 10 log 10（Pe /（1-Pe）），可能为负。 PHRED分数和Solexa分数不可互换（但它们之间可以实现合理的映射，并且对于更高质量的读取，它们大致相等）。
令人困惑的是，早期的Solexa管道生成了一个类似FASTQ的文件，但使用了自己的分数映射和64的ASC偏差。更糟糕的是，对于Solexa/Illumina管道1.3以后，他们引入了FASTQ文件格式的第三种变体，这次使用PHRED分数（更一致），但具有64的ASC偏差。
即，FASTQ文件格式至少有三种不同且不兼容的变体：原始的Sanger PHRED标准，以及来自Solexa/Illumina的两种。
好消息是，从CASAVA 1.8版本起，Illumina测序器将使用标准Sanger编码生成FASTQ文件。
您需要通过Bio.SeqIO函数使用此模块，格式名称如下：
“qual”是指使用PHRED分数的简单质量文件（例如来自Roche 454）
“fastq”是指使用PHRED分数和ASCII偏移33的Sanger风格FASTQ文件（例如来自NCBI Short Read Archive和Illumina 1.8+）。这些可以潜在地保持PHRED分数从0到93。
“fastq-sanger”是“fastq”的别名。
“fastq-solexa”意味着旧的Solexa（以及非常早期的Illumina）风格的FASTQ文件，使用具有ASC偏差64的Solexa分数。这些可以将Solexa得分保持在-5到62之间。
“fastq-illumina”指的是较新的Illumina 1.3至1.7风格的FASTQ文件，使用PHRED分数，但具有64的ASC偏差，允许PHRED分数从0到62。
我们可能会添加对“qual-solexa”的支持，即包含Solexa分数的QUAL文件，但到目前为止没有任何理由使用此类文件。
例如，考虑以下简短的FASTQ文件：：
@EAS54_6_R1_2_1_413_324
CCCTTCTTGTCTTCAGCGTTTCTCC
+
;;3;;;;;;;;;;;;7;;;;;;;88
@EAS54_6_R1_2_1_540_792
TTGGCAGGCCAAGGCCGATGGATCA
+
;;;;;;;;;;;7;;;;;-;;;3;83
@EAS54_6_R1_2_1_443_348
GTTGCTTCTGGCGTGGGTGGGGGGG
+
;;;;;;;;;;;9;7;;.7;393333
其中包含三个长度为25的读数。 从读段长度来看，这些可能最初来自早期的Solexa/Illumina测序仪，但该文件遵循Sanger FASTQ惯例（PHRED风格品质，ASC偏差为33）。 这意味着我们可以使用Bio.SeqIO解析此文件，并使用“fastq”作为格式名称：
>>> from Bio import SeqIO
>>> for record in SeqIO.parse("Quality/example.fastq", "fastq"):
... print("%s %s" % (record.id, record.seq))
EAS54_6_R1_2_1_413_324 CCCTTCTTGTCTTCAGCGTTTCTCC
EAS54_6_R1_2_1_540_792 TTGGCAGGCCAAGGCCGATGGATCA
EAS54_6_R1_2_1_443_348 GTTGCTTCTGGCGTGGGTGGGGGGG
这些质量在每个记录的注释中以一系列的形式保存：
>>> print(record)
ID: EAS54_6_R1_2_1_443_348
Name: EAS54_6_R1_2_1_443_348
Description: EAS54_6_R1_2_1_443_348
Number of features: 0
Per letter annotation for: phred_quality
Seq('GTTGCTTCTGGCGTGGGTGGGGGGG')
>>> print(record.letter_annotations["phred_quality"])
[26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 24, 26, 22, 26, 26, 13, 22, 26, 18, 24, 18, 18, 18, 18]
您可以使用SeqRecord格式方法以QUAL格式显示此内容：
>>> print(record.format("qual"))
>EAS54_6_R1_2_1_443_348
26 26 26 26 26 26 26 26 26 26 26 24 26 22 26 26 13 22 26 18
24 18 18 18 18
或者回到FASTQ格式，使用“fastq”（或“fastq-sanger”）：
>>> print(record.format("fastq"))
@EAS54_6_R1_2_1_443_348
GTTGCTTCTGGCGTGGGTGGGGGGG
+
;;;;;;;;;;;9;7;;.7;393333
或者，使用Illumina 1.3+ FASTQ编码（PHRED值，ASC偏差为64）：
>>> print(record.format("fastq-illumina"))
@EAS54_6_R1_2_1_443_348
GTTGCTTCTGGCGTGGGTGGGGGGG
+
ZZZZZZZZZZZXZVZZMVZRXRRRR
您还可以让Biopython转换分数并显示Solexa风格的FASTQ文件：
>>> print(record.format("fastq-solexa"))
@EAS54_6_R1_2_1_443_348
GTTGCTTCTGGCGTGGGTGGGGGGG
+
ZZZZZZZZZZZXZVZZMVZRXRRRR
请注意，这实际上是与上面使用“fastq-illumina”作为格式的输出相同的输出！原因是所有这些分数都足够高，以至于PHRED和Solexa分数几乎相等。对于质量差的读取，差异变得明显。有关详细信息，请参阅函数solexa_quality_from_phred和phred_quality_from_solexa。
如果您想修剪序列（可能是为了删除低质量区域，或删除碱基序列），请尝试对SeqRecord对象进行切片。 例如
>>> sub_rec = record[5:15]
>>> print(sub_rec)
ID: EAS54_6_R1_2_1_443_348
Name: EAS54_6_R1_2_1_443_348
Description: EAS54_6_R1_2_1_443_348
Number of features: 0
Per letter annotation for: phred_quality
Seq('TTCTGGCGTG')
>>> print(sub_rec.letter_annotations["phred_quality"])
[26, 26, 26, 26, 26, 26, 24, 26, 22, 26]
>>> print(sub_rec.format("fastq"))
@EAS54_6_R1_2_1_443_348
TTCTGGCGTG
+
;;;;;;9;7;
如果您愿意，可以读取此FASTQ文件，并将其保存为QUAL文件：
>>> from Bio import SeqIO
>>> record_iterator = SeqIO.parse("Quality/example.fastq", "fastq")
>>> with open("Quality/temp.qual", "w") as out_handle:
... SeqIO.write(record_iterator, out_handle, "qual")
3
当然，您可以阅读QUAL文件，例如我们刚刚创建的文件：
>>> from Bio import SeqIO
>>> for record in SeqIO.parse("Quality/temp.qual", "qual"):
... print("%s read of length %d" % (record.id, len(record.seq)))
EAS54_6_R1_2_1_413_324 read of length 25
EAS54_6_R1_2_1_540_792 read of length 25
EAS54_6_R1_2_1_443_348 read of length 25
请注意，QUAL文件没有正确的序列！ 但质量信息就在那里：
>>> print(record)
ID: EAS54_6_R1_2_1_443_348
Name: EAS54_6_R1_2_1_443_348
Description: EAS54_6_R1_2_1_443_348
Number of features: 0
Per letter annotation for: phred_quality
Undefined sequence of length 25
>>> print(record.letter_annotations["phred_quality"])
[26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 24, 26, 22, 26, 26, 13, 22, 26, 18, 24, 18, 18, 18, 18]
为了保持整洁，如果您自己正在遵循此示例，您现在可以删除此临时文件：
>>> import os
>>> os.remove("Quality/temp.qual")
有时您不会有FASTQ文件，而只有一对FASTA和QUAL文件。 由于Bio.SeqIO系统专为读取单个文件而设计，因此您必须分别读取这两个文件，然后组合数据。 然而，由于这是一件很常见的事情，因此在此模块中定义了一个帮助迭代器，可以为您完成这一任务-PairedFastaQuality Iterator。
或者，如果您有足够的RAM来同时保存内存中的所有记录，那么简单的字典方法也可以起作用：
>>> from Bio import SeqIO
>>> reads = SeqIO.to_dict(SeqIO.parse("Quality/example.fasta", "fasta"))
>>> for rec in SeqIO.parse("Quality/example.qual", "qual"):
... reads[rec.id].letter_annotations["phred_quality"]=rec.letter_annotations["phred_quality"]
然后，您可以通过其键访问任何记录，并获得序列和质量分数。
>>> print(reads["EAS54_6_R1_2_1_540_792"].format("fastq"))
@EAS54_6_R1_2_1_540_792
TTGGCAGGCCAAGGCCGATGGATCA
+
;;;;;;;;;;;7;;;;;-;;;3;83
重要的是，您要明确告诉Bio.SeqIO您正在使用哪个FASTQ变体（使用PHRED值的Sanger标准为“fastq”或“fastq-sanger”，原始Solexa/Illumina变体为“fastq-solexa”，或更新的变体为“fastq-illumina”），因为这无法可靠地自动检测。
为了说明这个问题，让我们考虑一个人为的例子：
>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> test = SeqRecord(Seq("NACGTACGTA"), id="Test", description="Made up!")
>>> print(test.format("fasta"))
>Test Made up!
NACGTACGTA
>>> print(test.format("fastq"))
Traceback (most recent call last):
...
ValueError: No suitable quality scores found in letter_annotations of SeqRecord (id=Test).
我们创建了一个示例SeqRecord，并且可以以FASTA格式显示它-但对于QUAL或FASTQ格式，我们需要提供一些质量分数。这些在letter_annotations字典中作为一个整数列表（每个进制一个）保存：
>>> test.letter_annotations["phred_quality"] = [0, 1, 2, 3, 4, 5, 10, 20, 30, 40]
>>> print(test.format("qual"))
>Test Made up!
0 1 2 3 4 5 10 20 30 40
>>> print(test.format("fastq"))
@Test Made up!
NACGTACGTA
+
!"#$%&+5?I
我们可以检查这个FASTQ编码-第一个PHRED质量为零，这映射到感叹号，而最终分数为40，这映射到字母“I”：
>>> ord('!') - 33
0
>>> ord('I') - 33
40
>>> [ord(letter)-33 for letter in '!"#$%&+5?I']
[0, 1, 2, 3, 4, 5, 10, 20, 30, 40]
类似地，我们可以使用具有64个偏差的PHRED分数来生成Illumina 1.3至1.7风格的FASTQ文件：
>>> print(test.format("fastq-illumina"))
@Test Made up!
NACGTACGTA
+
@ABCDEJT^h
我们也可以检查这一点--第一个PHRED分数是零，这映射到“@”，而最终分数是40，这映射到“h”：
>>> ord("@") - 64
0
>>> ord("h") - 64
40
>>> [ord(letter)-64 for letter in "@ABCDEJT^h"]
[0, 1, 2, 3, 4, 5, 10, 20, 30, 40]
请注意，标准Sanger FASTQ和Illumina 1.3至1.7风格FASTQ文件查找相同数据的方式有多么不同！然后我们需要考虑较旧的Solexa/Illumina格式，该格式编码Solexa分数而不是PHRED分数。
首先，让我们看看如果我们将PHRED分数转换为Solexa分数（四舍五入到小数点后一位），Biopython会说什么：
>>> for q in [0, 1, 2, 3, 4, 5, 10, 20, 30, 40]:
... print("PHRED %i maps to Solexa %0.1f" % (q, solexa_quality_from_phred(q)))
PHRED 0 maps to Solexa -5.0
PHRED 1 maps to Solexa -5.0
PHRED 2 maps to Solexa -2.3
PHRED 3 maps to Solexa -0.0
PHRED 4 maps to Solexa 1.8
PHRED 5 maps to Solexa 3.3
PHRED 10 maps to Solexa 9.5
PHRED 20 maps to Solexa 20.0
PHRED 30 maps to Solexa 30.0
PHRED 40 maps to Solexa 40.0
现在，这是使用旧Solexa风格FASTQ文件的记录：
>>> print(test.format("fastq-solexa"))
@Test Made up!
NACGTACGTA
+
;;>@BCJT^h
同样，这使用的是64的ASC偏置，因此我们可以检查Solexa分数：
>>> [ord(letter)-64 for letter in ";;>@BCJT^h"]
[-5, -5, -2, 0, 2, 3, 10, 20, 30, 40]
这解释了为什么FASTQ输出的最后几个字母与使用Illumina 1.3至1.7格式的结果相匹配-高质量PHRED分数和Solexa分数大致相等。
- Bio.SeqIO.QualityIO.solexa_quality_from_phred(phred_quality: float) float
将PHRED质量（范围0至约90）转换为Solexa质量。
PHRED和Solexa质量分数都是错误概率的对数转换（高分=错误概率低）。该函数获取PHRED分数，将其转换回错误概率，然后将其重新表达为Solexa分数。这假设误差估计是等效的。
这到底是如何运作的？PHRED质量是错误概率以十为底的对数的负十倍：：
phred_quality = -10*log(error,10)
因此，扭转局面：：
error = 10 ** (- phred_quality / 10)
现在，Solexa quality使用不同的log转换：：
solexa_quality = -10*log(error/(1-error),10)
经过替换和一点操纵，我们得到：：
solexa_quality = 10*log(10**(phred_quality/10.0) - 1, 10)
然而，真实的Solexa文件使用的最低质量为-5。这确实有充分的理由--随机碱基调用将有25%的时间是正确的，因此错误概率为0.75，这使得PHRED质量为1.25，或者Solexa质量为-4.77。因此（四舍五入后），随机核苷读数的PHRED质量为1，或Solexa质量为-5。
从字面上看，这个热力学公式将零的PHRED质量映射到负无限的Solexa质量。当然，从字面上看，PHRED分数为零意味着错误的概率为一（即基本呼叫肯定是错误的），这比随机更糟糕！在实践中，PHRED质量为零通常意味着默认值，或者可能是随机的-因此将其映射到最低Solexa评分-5是合理的。
总之，我们遵循BROSS，并采用此对数公式，但也为Solexa质量应用最小值-5.0，并且还将PHRED质量从0映射到-5.0。
请注意，此函数将返回一个浮点数，如果合适，您可以自行决定将其四舍五入到最接近的整数。 例如
>>> print("%0.2f" % round(solexa_quality_from_phred(80), 2)) 80.00 >>> print("%0.2f" % round(solexa_quality_from_phred(50), 2)) 50.00 >>> print("%0.2f" % round(solexa_quality_from_phred(20), 2)) 19.96 >>> print("%0.2f" % round(solexa_quality_from_phred(10), 2)) 9.54 >>> print("%0.2f" % round(solexa_quality_from_phred(5), 2)) 3.35 >>> print("%0.2f" % round(solexa_quality_from_phred(4), 2)) 1.80 >>> print("%0.2f" % round(solexa_quality_from_phred(3), 2)) -0.02 >>> print("%0.2f" % round(solexa_quality_from_phred(2), 2)) -2.33 >>> print("%0.2f" % round(solexa_quality_from_phred(1), 2)) -5.00 >>> print("%0.2f" % round(solexa_quality_from_phred(0), 2)) -5.00
请注意，对于高质量的阅读，PHRED和Solexa分数在数字上是相等的。这些差异对于质量较差的读取非常重要，其中PHRED的最低值为零，但Solexa的分数可能为负。
最后，作为“无”用于“缺失值”的特殊情况，返回无：
>>> print(solexa_quality_from_phred(None)) None
- Bio.SeqIO.QualityIO.phred_quality_from_solexa(solexa_quality: float) float
将Solexa质量（可以是负的）转换为PHRED质量。
PHRED和Solexa质量分数都是错误概率的对数转换（高分=错误概率低）。该函数获取Solexa分数，将其转换回错误概率，然后将其重新表达为PHRED分数。这假设误差估计是等效的。
姊妹函数solexa_quality_from_phred的文档中给出了基础公式，在这种情况下，操作为：
phred_quality = 10*log(10**(solexa_quality/10.0) + 1, 10)
这将返回一个浮点数，如果合适的话，您可以将其四舍五入到最接近的整数。 例如
>>> print("%0.2f" % round(phred_quality_from_solexa(80), 2)) 80.00 >>> print("%0.2f" % round(phred_quality_from_solexa(20), 2)) 20.04 >>> print("%0.2f" % round(phred_quality_from_solexa(10), 2)) 10.41 >>> print("%0.2f" % round(phred_quality_from_solexa(0), 2)) 3.01 >>> print("%0.2f" % round(phred_quality_from_solexa(-5), 2)) 1.19
请注意，预计solexa_quality小于-5，将触发警告，但仍会根据对数映射进行转换（返回0到1.19之间的数字）。
作为“缺失值”使用无值的特殊情况，返回无值：
>>> print(phred_quality_from_solexa(None)) None
- Bio.SeqIO.QualityIO.FastqGeneralIterator(source: IO[str] | PathLike | str | bytes) Iterator[tuple[str, str, str]]
将Fastq记录作为字符串二元组（而不是作为SeqRecord对象）进行迭代。
- 论点：
源-以文本模式打开的输入流，或文件的路径
此代码不会尝试用数字方式解释质量字符串。 它只是以字符串形式返回标题、序列和质量的二元组。 对于序列和质量，任何空白（例如新行）都会被删除。
我们基于SeqRecord的FASTQ迭代器在内部调用该函数，然后将字符串转换为SeqRecord对象，将质量字符串映射为数字分数列表。 如果您想进行自定义质量映射，那么您可以考虑直接调用此函数。
对于解析FASTQ文件，可以选择在“+”行省略每条记录开始处“@”行的标题字符串。 如果重复，则必须相同。
序列字符串和质量字符串可以选择性地拆分为多行，尽管有几个来源不鼓励这样做。 相比之下，对于FASTA文件格式，60到80个字符之间的换行符是正常的。
WARNING - 由于“@”字符可能出现在质量字符串中，因此这可能会导致问题，因为这也是新序列开始的标记。 事实上，“+”标志也可以出现。 一些消息来源建议质量中没有断线来避免这种情况，但即使这还不够，请考虑这个例子：
@071113_EAS56_0053:1:1:998:236 TTTCTTGCCCCCATAGACTGAGACCTTCCCTAAATA +071113_EAS56_0053:1:1:998:236 IIIIIIIIIIIIIIIIIIIIIIIIIIIIICII+III @071113_EAS56_0053:1:1:182:712 ACCCAGCTAATTTTTGTATTTTTGTTAGAGACAGTG + @IIIIIIIIIIIIIIICDIIIII<%<6&-*).(*%+ @071113_EAS56_0053:1:1:153:10 TGTTCTGAAGGAAGGTGTGCGTGCGTGTGTGTGTGT + IIIIIIIIIIIICIIGIIIII>IAIIIE65I=II:6 @071113_EAS56_0053:1:3:990:501 TGGGAGGTTTTATGTGGA AAGCAGCAATGTACAAGA + IIIIIII.IIIIII1@44 @-7.%<&+/$/%4(++(%
这是四个PHRED编码的FASTQ条目，最初来自NCBI来源（鉴于读取长度为36，这些可能是Solexa Illumina读取，其中质量已映射到PHRED值）。
此示例经过编辑，以说明FASTQ格式中允许的一些讨厌的事情。 首先，在“+”行上，省略了大部分（冗余）标识符。 在实际文件中，这些额外标识符可能全部或不存在。
其次，虽然前三个序列显示时没有断线，但最后一个序列被分成多行。 在实际文件中，任何断点都可能是一致的。
第三，一些优质字符串行以“@”字符开头。 对于第二个记录，这是不可避免的。 然而，对于第四个序列来说，这种情况只会发生，因为它的质量字符串被分成两行。 天真的解析器可能会错误地将任何以“@”开头的行视为新序列的开始！ 该代码通过跟踪序列的长度来应对这种可能的歧义，该序列给出了质量字符串的预期长度。
使用这个棘手的示例文件作为输入，这段简短的代码演示了这个解析函数将返回什么：
>>> with open("Quality/tricky.fastq") as handle: ... for (title, sequence, quality) in FastqGeneralIterator(handle): ... print(title) ... print("%s %s" % (sequence, quality)) ... 071113_EAS56_0053:1:1:998:236 TTTCTTGCCCCCATAGACTGAGACCTTCCCTAAATA IIIIIIIIIIIIIIIIIIIIIIIIIIIIICII+III 071113_EAS56_0053:1:1:182:712 ACCCAGCTAATTTTTGTATTTTTGTTAGAGACAGTG @IIIIIIIIIIIIIIICDIIIII<%<6&-*).(*%+ 071113_EAS56_0053:1:1:153:10 TGTTCTGAAGGAAGGTGTGCGTGCGTGTGTGTGTGT IIIIIIIIIIIICIIGIIIII>IAIIIE65I=II:6 071113_EAS56_0053:1:3:990:501 TGGGAGGTTTTATGTGGAAAGCAGCAATGTACAAGA IIIIIII.IIIIII1@44@-7.%<&+/$/%4(++(%
最后，我们注意到一些来源指出质量字符串应该以“！”开头”（使用PHRED映射意味着第一个字母的质量评分始终为零）。 这一相当严格的规则没有得到广泛遵守，因此在这里被忽视。 这一点有一个优点”！“规则是（假设质量序列中没有断点）它将防止“@”字符出现上述问题。
- class Bio.SeqIO.QualityIO.FastqIteratorAbstractBaseClass(source)
基类：
SequenceIterator[str]FASTQ文件解析器的抽象基类。
- modes = 't'
- abstract property q_mapping
将质量字符串中的字母映射到质量值的字典。
- abstract property q_key
record.letter_annotations中质量值的关键名称（字符串）。
- __init__(source)
将FASTQ记录作为SeqRecord对象进行迭代。
- 论点：
源-以文本模式打开的输入流，或文件的路径
质量值存储在 letter_annotations 键下的字典属性 q_key .
- __abstractmethods__ = frozenset({'q_key', 'q_mapping'})
- __annotations__ = {}
- __firstlineno__ = 1001
- __orig_bases__ = (Bio.SeqIO.Interfaces.SequenceIterator[str],)
- __parameters__ = ()
- __static_attributes__ = ('line',)
- class Bio.SeqIO.QualityIO.FastqPhredIterator(source: IO[str] | PathLike | str | bytes, alphabet: None = None)
基类：
FastqIteratorAbstractBaseClassFASTQ文件的解析器。
- q_mapping = b'\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8'
- q_key = 'phred_quality'
- __init__(source: IO[str] | PathLike | str | bytes, alphabet: None = None)
将FASTQ记录作为SeqRecord对象进行迭代。
- 论点：
源-以文本模式打开的输入流，或文件的路径
字母表-可选字母表，不再使用。离开为无。
对于（Sanger样式）FASTQ文件中的每个序列，都有一个匹配字符串，使用偏移量为33的ASCII值对PHRED质量（0到大约90之间的整数）进行编码。
例如，考虑一个包含三个短读取的文件：
@EAS54_6_R1_2_1_413_324 CCCTTCTTGTCTTCAGCGTTTCTCC + ;;3;;;;;;;;;;;;7;;;;;;;88 @EAS54_6_R1_2_1_540_792 TTGGCAGGCCAAGGCCGATGGATCA + ;;;;;;;;;;;7;;;;;-;;;3;83 @EAS54_6_R1_2_1_443_348 GTTGCTTCTGGCGTGGGTGGGGGGG + ;;;;;;;;;;;9;7;;.7;393333
对于每个序列（例如“CCCTTCTTGTCTTCAGCGTTTCTCC”），都有一个匹配字符串，使用具有33个偏置的ASCI值对PHRED质量进行编码（例如“; 3;88”）。
直接使用此模块您可能会运行：
>>> with open("Quality/example.fastq") as handle: ... for record in FastqPhredIterator(handle): ... print("%s %s" % (record.id, record.seq)) EAS54_6_R1_2_1_413_324 CCCTTCTTGTCTTCAGCGTTTCTCC EAS54_6_R1_2_1_540_792 TTGGCAGGCCAAGGCCGATGGATCA EAS54_6_R1_2_1_443_348 GTTGCTTCTGGCGTGGGTGGGGGGG
然而，通常您会通过Bio.SeqIO将其称为“fastq”（或“fastq-sanger”）作为格式：
>>> from Bio import SeqIO >>> with open("Quality/example.fastq") as handle: ... for record in SeqIO.parse(handle, "fastq"): ... print("%s %s" % (record.id, record.seq)) EAS54_6_R1_2_1_413_324 CCCTTCTTGTCTTCAGCGTTTCTCC EAS54_6_R1_2_1_540_792 TTGGCAGGCCAAGGCCGATGGATCA EAS54_6_R1_2_1_443_348 GTTGCTTCTGGCGTGGGTGGGGGGG
如果您想查看这些质量，它们会作为简单的整表记录在每条记录的每字母注释字典中：
>>> print(record.letter_annotations["phred_quality"]) [26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 24, 26, 22, 26, 26, 13, 22, 26, 18, 24, 18, 18, 18, 18]
要修改解析器返回的记录，可以使用生成器函数。例如，要在记录描述中存储平均PHRED质量，请使用
>>> from statistics import mean >>> def modify_records(records): ... for record in records: ... record.description = mean(record.letter_annotations['phred_quality']) ... yield record ... >>> with open('Quality/example.fastq') as handle: ... for record in modify_records(FastqPhredIterator(handle)): ... print(record.id, record.description) ... EAS54_6_R1_2_1_413_324 25.28 EAS54_6_R1_2_1_540_792 24.52 EAS54_6_R1_2_1_443_348 23.4
- __abstractmethods__ = frozenset({})
- __annotations__ = {}
- __firstlineno__ = 1132
- __parameters__ = ()
- __static_attributes__ = ()
- class Bio.SeqIO.QualityIO.FastqSolexaIterator(source: IO[str] | PathLike | str | bytes, alphabet: None = None)
基类：
FastqIteratorAbstractBaseClass旧Solexa/Illumina FASTQ类似文件的解析器。
这些文件的质量映射不同。
- q_mapping = b'\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xfb\xfc\xfd\xfe\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8'
- q_key = 'solexa_quality'
- __init__(source: IO[str] | PathLike | str | bytes, alphabet: None = None)
将FASTQ记录作为SeqRecord对象进行迭代。
- 论点：
源-以文本模式打开的输入流，或文件的路径
字母表-可选字母表，不再使用。离开为无。
对于Solexa/Illumina FASTQ文件中的每个序列，都有一个匹配的字符串，使用具有64的错开量的ASC值对Solexa整值进行编码。 Solexa分数的缩放方式与PHRED分数不同，Biopython在加载时不会执行任何自动转换。
注-Solexa/ Illumina管道的旧版本使用此文件格式。另请参阅新版本的FastqIlluminaIterator函数。
例如，考虑一个包含以下五条记录的文件：
@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ
直接使用此模块您可能会运行：
>>> with open("Quality/solexa_example.fastq") as handle: ... for record in FastqSolexaIterator(handle): ... print("%s %s" % (record.id, record.seq)) SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA
然而，通常您会通过Bio.SeqIO将其称为“fastq-solexa”作为格式：
>>> from Bio import SeqIO >>> with open("Quality/solexa_example.fastq") as handle: ... for record in SeqIO.parse(handle, "fastq-solexa"): ... print("%s %s" % (record.id, record.seq)) SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA
质量记录在每个记录的每个字母注释字典中，作为一个简单的整数列表：
>>> print(record.letter_annotations["solexa_quality"]) [25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 23, 25, 25, 25, 25, 23, 25, 23, 23, 21, 23, 23, 23, 17, 17]
这些分数不是很好，但足够高，几乎完全映射到PHRED分数：
>>> print("%0.2f" % phred_quality_from_solexa(25)) 25.01
让我们看看伪造的示例阅读，它更糟糕，其中Solexa和PHRED分数之间存在更明显的差异：：
@slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN +slxa_0001_1_0001_01 hgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;
同样，您通常会使用Bio.SeqIO来读取这个文件（而不是直接调用Bio.SeqIO.QualtityIO模块）。 大多数FASTQ文件将包含数千个读取，因此通常使用如上所示的Bio.SeqIO.parse（）。 这个例子只有一个条目，所以我们可以使用Bio.SeqIO.read（）函数：
>>> from Bio import SeqIO >>> with open("Quality/solexa_faked.fastq") as handle: ... record = SeqIO.read(handle, "fastq-solexa") >>> print("%s %s" % (record.id, record.seq)) slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN >>> print(record.letter_annotations["solexa_quality"]) [40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5]
这些质量分数非常低，以至于当从Solexa计划转换为PHRED分数时，它们看起来非常不同：
>>> print("%0.2f" % phred_quality_from_solexa(-1)) 2.54 >>> print("%0.2f" % phred_quality_from_solexa(-5)) 1.19
请注意，您可以使用Bio.SeqIO. writer（）函数或SeqRecord的格式方法来输出记录：
>>> print(record.format("fastq-solexa")) @slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN + hgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;
请注意，此输出与输入文件略有不同，因为Biopython省略了“+”行上序列标识符的可选重复。 如果您希望使用PHRED分数，请使用“fastq”或“qual”作为输出格式，Biopython将为您进行转换：
>>> print(record.format("fastq")) @slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN + IHGFEDCBA@?>=<;:9876543210/.-,++*)('&&%%$$##""
>>> print(record.format("qual")) >slxa_0001_1_0001_01 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 10 9 8 7 6 5 5 4 4 3 3 2 2 1 1
如上所示，质量较差的Solexa读数已映射到等效的PHRED评分（例如，如前所示的-5比1）。
- __abstractmethods__ = frozenset({})
- __annotations__ = {}
- __firstlineno__ = 1236
- __parameters__ = ()
- __static_attributes__ = ()
- class Bio.SeqIO.QualityIO.FastqIlluminaIterator(source: IO[str] | PathLike | str | bytes, alphabet: None = None)
基类：
FastqIteratorAbstractBaseClassIllumina 1.3至1.7 FASTQ类似文件的解析器。
这些文件的质量映射不同。
- q_mapping = b'\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8\xc8'
- q_key = 'phred_quality'
- __init__(source: IO[str] | PathLike | str | bytes, alphabet: None = None)
将FASTQ记录作为SeqRecord对象进行迭代。
- 论点：
源-以文本模式打开的输入流，或文件的路径
字母表-可选字母表，不再使用。离开为无。
对于Illumina 1.3+ FASTQ文件中的每个序列，都有一个匹配的字符串，该字符串使用具有64的错开量的ASC值来编码PHRED整值。
>>> from Bio import SeqIO >>> record = SeqIO.read("Quality/illumina_faked.fastq", "fastq-illumina") >>> print("%s %s" % (record.id, record.seq)) Test ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTN >>> max(record.letter_annotations["phred_quality"]) 40 >>> min(record.letter_annotations["phred_quality"]) 0
注-Solexa/Illumina管道的旧版本以64的ASC偏差编码Solexa分数。它们大致相等，但仅适用于高质量的读取。如果您有一个Solexa/Illumina旧文件，Solexa分数为负，并尝试将其作为Illumina 1.3+文件读取，则会失败：
>>> record2 = SeqIO.read("Quality/solexa_faked.fastq", "fastq-illumina") Traceback (most recent call last): ... Bio.SeqIO.QualityIO.InvalidCharError: Invalid character (?) or (0x3f) in quality string not in correct range (are you sure you're using the right QualityIO parser?) with context: [...BA@?>=<...]
注- True Sanger风格FASTQ文件使用PHRED分数，偏差为33。
- __abstractmethods__ = frozenset({})
- __annotations__ = {}
- __firstlineno__ = 1401
- __parameters__ = ()
- __static_attributes__ = ()
- class Bio.SeqIO.QualityIO.QualPhredIterator(source: IO[str] | PathLike | str | bytes, alphabet: None = None)
-
具有PHRED质量分数但没有序列的QUAL文件的解析器。
- modes = 't'
- __init__(source: IO[str] | PathLike | str | bytes, alphabet: None = None) None
对于包括PHRED质量评分但无序列的QUAL文件。
例如，考虑这个简短的QUAL文件：：
>EAS54_6_R1_2_1_413_324 26 26 18 26 26 26 26 26 26 26 26 26 26 26 26 22 26 26 26 26 26 26 26 23 23 >EAS54_6_R1_2_1_540_792 26 26 26 26 26 26 26 26 26 26 26 22 26 26 26 26 26 12 26 26 26 18 26 23 18 >EAS54_6_R1_2_1_443_348 26 26 26 26 26 26 26 26 26 26 26 24 26 22 26 26 13 22 26 18 24 18 18 18 18
直接使用此模块您可能会运行：
>>> with open("Quality/example.qual") as handle: ... for record in QualPhredIterator(handle): ... print("%s read of length %d" % (record.id, len(record.seq))) EAS54_6_R1_2_1_413_324 read of length 25 EAS54_6_R1_2_1_540_792 read of length 25 EAS54_6_R1_2_1_443_348 read of length 25
然而，通常您会通过Bio.SeqIO将其称为“qual”作为格式：
>>> from Bio import SeqIO >>> with open("Quality/example.qual") as handle: ... for record in SeqIO.parse(handle, "qual"): ... print("%s read of length %d" % (record.id, len(record.seq))) EAS54_6_R1_2_1_413_324 read of length 25 EAS54_6_R1_2_1_540_792 read of length 25 EAS54_6_R1_2_1_443_348 read of length 25
只有序列长度是已知的，因为QUAL文件不包含序列字符串本身。
质量分数本身在每条记录的每字母注释中作为一组整列可用：
>>> print(record.letter_annotations["phred_quality"]) [26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 24, 26, 22, 26, 26, 13, 22, 26, 18, 24, 18, 18, 18, 18]
您仍然可以切片以下SeqRecord对象之一：
>>> sub_record = record[5:10] >>> print("%s %s" % (sub_record.id, sub_record.letter_annotations["phred_quality"])) EAS54_6_R1_2_1_443_348 [26, 26, 26, 26, 26]
自Biopython 1.59起，此解析器将接受质量分数为负的文件，但将用尽可能低的PHRED分数零替换它们。这将触发警告，之前它引发了Value错误异常。
- __abstractmethods__ = frozenset({})
- __annotations__ = {}
- __firstlineno__ = 1461
- __parameters__ = ()
- __static_attributes__ = ('_line',)
- class Bio.SeqIO.QualityIO.FastqPhredWriter(target: IO | PathLike | str | bytes)
-
编写标准FASTQ格式文件（使用PHRED质量分数）（ObSOSYS）。
尽管您可以直接使用此类，但强烈建议您使用
as_fastq功能，或顶级Bio.SeqIO.write()而是通过格式名称“fastq”或别名“fastq-sanger”来调用函数。例如，此代码读取标准Sanger风格的FASTQ文件（使用PHRED分数）并将其重新保存为另一个Sanger风格的FASTQ文件：
>>> from Bio import SeqIO >>> record_iterator = SeqIO.parse("Quality/example.fastq", "fastq") >>> with open("Quality/temp.fastq", "w") as out_handle: ... SeqIO.write(record_iterator, out_handle, "fastq") 3
如果原始文件包含额外的断点（虽然有效，但可能并非所有工具都支持），则您可能需要执行此操作。 Biopython的输出文件将在一行中包含每个序列，并在一行中包含每个质量字符串（这被认为是为了最大限度地兼容性所需的）。
在下一个示例中，使用PHRED质量将旧风格的Solexa/Illumina FASTQ文件（使用Solexa质量分数）转换为标准的Sanger风格FASTQ文件：
>>> from Bio import SeqIO >>> record_iterator = SeqIO.parse("Quality/solexa_example.fastq", "fastq-solexa") >>> with open("Quality/temp.fastq", "w") as out_handle: ... SeqIO.write(record_iterator, out_handle, "fastq") 5
如果您使用SeqRecord的. form（“fastq”）方法，也会调用此代码，或者如果您喜欢该别名，也会调用. form（“fastq-sanger”）。
请注意，Sanger FASTQ文件的PHRED质量上限为93，编码为ASCII 126（波浪号）。如果您的质量分数被截断以适合，则会发出警告。
P.S.为了避免使工作目录变得混乱，您现在可以删除此临时文件：
>>> import os >>> os.remove("Quality/temp.fastq")
- modes = 't'
- __abstractmethods__ = frozenset({})
- __annotations__ = {}
- __firstlineno__ = 1580
- __parameters__ = ()
- __static_attributes__ = ()
- Bio.SeqIO.QualityIO.as_fastq(record: SeqRecord) str
将SeqRecord转换为Sanger FASTQ格式的字符串。
SeqRecord的. form（“fastq”）方法和SeqIO. writer（.，...,“fastq”）函数，也采用别名“fastq-sanger”格式。
- class Bio.SeqIO.QualityIO.QualPhredWriter(handle: IO[str] | PathLike | str | bytes, wrap: int = 60, record2title: Callable[[SeqRecord], str] | None = None)
-
编写QUAL格式文件（使用PHRED质量分数）（ObSOSYS）。
尽管您可以直接使用此类，但强烈建议您使用
as_qual功能，或顶级Bio.SeqIO.write()相反，功能。例如，此代码读取FASTQ文件并将质量分数保存到QUAL文件中：
>>> from Bio import SeqIO >>> record_iterator = SeqIO.parse("Quality/example.fastq", "fastq") >>> with open("Quality/temp.qual", "w") as out_handle: ... SeqIO.write(record_iterator, out_handle, "qual") 3
如果使用SeqRecord的. form（“qual”）方法，也会调用此代码。
P.S.如果您不再需要临时文件，请不要忘记清理它：
>>> import os >>> os.remove("Quality/temp.qual")
- modes = 't'
- __init__(handle: IO[str] | PathLike | str | bytes, wrap: int = 60, record2title: Callable[[SeqRecord], str] | None = None) None
创造一个合格的作家。
- 论点：
handle -输出文件的Handle，例如，打开返回的（文件名，“w”）
包裹物 - 用于包裹序列行的可选行长度。要求将序列包装为60个字符。使用零（或无）表示无包装，为序列给出一条长长的线。
record 2 title-可选函数，用于返回用于每条记录标题行的文本。 默认情况下，使用record.id和record. advantage的组合。 如果record. advantage以record.id开头，则仅使用record. advantage。
存在record 2title参数是为了与Bio.SeqIO.FastaIO编写器类保持一致。
- __abstractmethods__ = frozenset({})
- __annotations__ = {'wrap': 'Optional[int]'}
- __firstlineno__ = 1681
- __parameters__ = ()
- __static_attributes__ = ('record2title', 'wrap')
- Bio.SeqIO.QualityIO.as_qual(record: SeqRecord) str
将SeqRecord转换为QUAL格式的字符串。
SeqRecord的. form（“qual”）方法和SeqIO. writer（.，...,“qual”）功能。
- class Bio.SeqIO.QualityIO.FastqSolexaWriter(target: IO | PathLike | str | bytes)
-
编写老式Solexa/Illumina FASTQ格式文件（具有Solexa品质）（ObSOSYS）。
这会使用Solexa分数和64的ASC偏差输出FASTQ文件，类似于早期Solexa/Illumina管道中的文件。这些与标准Sanger风格的PHRED FASTQ文件不兼容。
如果您的记录在letter_annotations下包含“solexa_quality”条目，则使用该条目，否则在使用solexa_quality_from_phred函数进行转换后，将使用任何“phred_quality”条目。如果两种类型的质量分数都不存在，则会引发例外。
尽管您可以直接使用此类，但强烈建议您使用
as_fastq_solexa功能，或顶级Bio.SeqIO.write()相反，功能。 例如，以下代码读入一个FASTQ文件，并将其重新保存为另一个FASTQ文件：>>> from Bio import SeqIO >>> record_iterator = SeqIO.parse("Quality/solexa_example.fastq", "fastq-solexa") >>> with open("Quality/temp.fastq", "w") as out_handle: ... SeqIO.write(record_iterator, out_handle, "fastq-solexa") 5
如果原始文件包含额外的断点（虽然有效）可能并非所有工具都支持，则您可能需要执行此操作。 Biopython的输出文件将在一行中包含每个序列，并在一行中包含每个质量字符串（这被认为是为了最大限度地兼容性所需的）。
如果使用SeqRecord的. form（“fastq-solexa”）方法，也会调用此代码。例如，
>>> record = SeqIO.read("Quality/sanger_faked.fastq", "fastq-sanger") >>> print(record.format("fastq-solexa")) @Test PHRED qualities from 40 to 0 inclusive ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTN + hgfedcba`_^]\[ZYXWVUTSRQPONMLKJHGFECB@>;;
请注意，Solexa FASTQ文件的Solexa质量上限为62，编码为ASCI 126（波浪号）。 如果您的质量分数必须被截断以适应，则会发出警告。
P.S.如果您不再需要临时文件，请不要忘记删除它：
>>> import os >>> os.remove("Quality/temp.fastq")
- modes = 't'
- __abstractmethods__ = frozenset({})
- __annotations__ = {}
- __firstlineno__ = 1833
- __parameters__ = ()
- __static_attributes__ = ()
- Bio.SeqIO.QualityIO.as_fastq_solexa(record: SeqRecord) str
将SeqRecord转换为Solexa FASTQ格式的字符串。
SeqRecord的. form（“fastq-solexa”）方法和SeqIO. writer（.，...,“fastq-solexa”）功能。
- class Bio.SeqIO.QualityIO.FastqIlluminaWriter(target: IO | PathLike | str | bytes)
-
编写Illumina 1.3+ FASTQ格式的文件（带有PHRED质量评分）（OBSONOTE）。
它使用PHRED分数和64的ASC偏差输出FASTQ文件，类似于Solexa/Illumina 1.3+管道中的文件。请注意，这些文件与标准Sanger风格的PHRED FASTQ文件不兼容，该文件使用的是32的ASC偏置。
尽管您可以直接使用此类，但强烈建议您使用
as_fastq_illumina或顶级Bio.SeqIO.write()格式名称为“fastq-illumina”的函数。如果您使用SeqRecord的. form（“fastq-illumina”）方法，也会调用此代码。例如，>>> from Bio import SeqIO >>> record = SeqIO.read("Quality/sanger_faked.fastq", "fastq-sanger") >>> print(record.format("fastq-illumina")) @Test PHRED qualities from 40 to 0 inclusive ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTN + hgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@
请注意，Illumina FASTQ文件的PHRED质量上限为62，编码为ASCI 126（波浪号）。如果您的质量分数被截断以适合，则会发出警告。
- modes = 't'
- __abstractmethods__ = frozenset({})
- __annotations__ = {}
- __firstlineno__ = 1938
- __parameters__ = ()
- __static_attributes__ = ()
- Bio.SeqIO.QualityIO.as_fastq_illumina(record: SeqRecord) str
将SeqRecord转换为Illumina FASTQ格式的字符串。
SeqRecord的. form（“fastq-illumina”）方法和SeqIO. writer（.，...,“fastq-illumina”）功能。
- Bio.SeqIO.QualityIO.PairedFastaQualIterator(fasta_source: IO[str] | PathLike | str | bytes, qual_source: IO[str] | PathLike | str | bytes, alphabet: None = None) Iterator[SeqRecord]
将匹配的FASTA和QUAL文件作为SeqRecord对象迭代。
例如，考虑这个具有PHRED质量分数的简短QUAL文件：：
>EAS54_6_R1_2_1_413_324 26 26 18 26 26 26 26 26 26 26 26 26 26 26 26 22 26 26 26 26 26 26 26 23 23 >EAS54_6_R1_2_1_540_792 26 26 26 26 26 26 26 26 26 26 26 22 26 26 26 26 26 12 26 26 26 18 26 23 18 >EAS54_6_R1_2_1_443_348 26 26 26 26 26 26 26 26 26 26 26 24 26 22 26 26 13 22 26 18 24 18 18 18 18
和一个匹配的FASTA文件：
>EAS54_6_R1_2_1_413_324 CCCTTCTTGTCTTCAGCGTTTCTCC >EAS54_6_R1_2_1_540_792 TTGGCAGGCCAAGGCCGATGGATCA >EAS54_6_R1_2_1_443_348 GTTGCTTCTGGCGTGGGTGGGGGGG
您可以使用Bio.SeqIO以“qual”和“fasta”格式单独解析这些，但随后您将获得一组没有序列的SeqRecord对象，以及一组具有序列但没有质量的匹配组。 由于Bio.SeqIO仅处理一个输入文件柄，因此不能使用Bio.SeqIO来一起读取这两个文件-但此函数可以！例如，
>>> with open("Quality/example.fasta") as f: ... with open("Quality/example.qual") as q: ... for record in PairedFastaQualIterator(f, q): ... print("%s %s" % (record.id, record.seq)) ... EAS54_6_R1_2_1_413_324 CCCTTCTTGTCTTCAGCGTTTCTCC EAS54_6_R1_2_1_540_792 TTGGCAGGCCAAGGCCGATGGATCA EAS54_6_R1_2_1_443_348 GTTGCTTCTGGCGTGGGTGGGGGGG
与FASTQ或QUAL解析器一样，如果您想查看质量，它们在每条记录的每字母注释字典中作为简单的整表：
>>> print(record.letter_annotations["phred_quality"]) [26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 24, 26, 22, 26, 26, 13, 22, 26, 18, 24, 18, 18, 18, 18]
如果您可以以FASTQ格式文件的形式访问数据，则直接使用该文件会更简单、更直接。 请注意，您可以轻松使用此功能将配对的FASTA和QUAL文件转换为FASTQ文件：
>>> from Bio import SeqIO >>> with open("Quality/example.fasta") as f: ... with open("Quality/example.qual") as q: ... SeqIO.write(PairedFastaQualIterator(f, q), "Quality/temp.fastq", "fastq") ... 3
如果您不再需要临时文件，请不要忘记清理它：
>>> import os >>> os.remove("Quality/temp.fastq")
- exception Bio.SeqIO.QualityIO.InvalidCharError(full_string: str, index: int, details: str, r: int = 3)
基类：
ValueError具有因任何原因无效的字符串的自定义错误（例如：非默认、无效范围）
- 主要属性：
完整字符串 - 包含无效字符（字符串）的字符串
指数 - full_字符串中无效字符的位置（int）
细节 - 要添加到错误消息中的附加信息。比如：“不在正确的范围内”（字符串）
R - 错误消息中要包含无效字符每一侧的多少个字符（int）
- full_string: str
- index: int
- details: str
- r: int = 3
- __str__() str
返回url（self）。
- __annotations__ = {'details': <class 'str'>, 'full_string': <class 'str'>, 'index': <class 'int'>, 'r': <class 'int'>}
- __dataclass_fields__ = {'details': Field(name='details',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'full_string': Field(name='full_string',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'index': Field(name='index',type=<class 'int'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'r': Field(name='r',type=<class 'int'>,default=3,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
- __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
- __eq__(other)
返回自我==价值。
- __firstlineno__ = 2484
- __hash__ = None
- __init__(full_string: str, index: int, details: str, r: int = 3) None
- __match_args__ = ('full_string', 'index', 'details', 'r')
- __replace__(**changes)
- __repr__()
返回repr（self）。
- __static_attributes__ = ()