Bio.SeqRecord 模組

表示一個序列記錄，一個帶有註釋的序列。

class Bio.SeqRecord.SeqRecord(seq: Seq | MutableSeq | None, id: str | None = '<unknown id>', name: str = '<unknown name>', description: str = '<unknown description>', dbxrefs: list[str] | None = None, features: list[SeqFeature] | None = None, annotations: dict[str, str | int] | None = None, letter_annotations: dict[str, Sequence[Any]] | None = None)

基底類別：object

SeqRecord 物件保存一個序列及其相關資訊。

主要屬性

• id - 識別符，例如基因座標籤 (字串)

• seq - 序列本身 (Seq 物件或類似物件)

額外屬性

• name - 序列名稱，例如基因名稱 (字串)

• description - 額外文字 (字串)

• dbxrefs - 資料庫交叉參考清單 (字串清單)

• features - 定義的任何 (子) 特徵 (SeqFeature 物件清單)

• annotations - 關於整個序列的進一步資訊 (字典)。大多數條目是字串或字串清單。

• letter_annotations - 每個字母/符號的註釋 (受限字典)。這保存長度與序列長度匹配的 Python 序列 (清單、字串或元組)。一個典型的用途是保存代表定序品質分數的整數列表，或代表二級結構的字串。

您通常會使用 Bio.SeqIO 從檔案中讀取序列作為 SeqRecord 物件。但是，您可能需要直接建立自己的 SeqRecord 物件 (請參閱 __init__ 方法以了解更多詳細資訊)

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein")
>>> print(record)
ID: YP_025292.1
Name: HokC
Description: toxic membrane protein
Number of features: 0
Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')

如果要將 SeqRecord 物件儲存到序列檔案中，請使用 Bio.SeqIO。對於您想要將 SeqRecord 轉換為特定檔案格式字串的特殊情況，有一個在內部使用 Bio.SeqIO 的 format 方法

>>> print(record.format("fasta"))
>YP_025292.1 toxic membrane protein
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

您還可以執行諸如切片 SeqRecord、檢查其長度等操作

>>> len(record)
44
>>> edited = record[:10] + record[11:]
>>> print(edited.seq)
MKQHKAMIVAIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF
>>> print(record.seq)
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

__init__(seq: Seq | MutableSeq | None, id: str | None = '<unknown id>', name: str = '<unknown name>', description: str = '<unknown description>', dbxrefs: list[str] | None = None, features: list[SeqFeature] | None = None, annotations: dict[str, str | int] | None = None, letter_annotations: dict[str, Sequence[Any]] | None = None) → None

建立一個 SeqRecord。

參數

• seq - 序列，必要 (Seq 或 MutableSeq)

• id - 序列識別符，建議 (字串)

• name - 序列名稱，可選 (字串)

• description - 序列描述，可選 (字串)

• dbxrefs - 資料庫交叉參考，可選 (字串清單)

• features - 任何 (子) 特徵，可選 (SeqFeature 物件清單)

• annotations - 整個序列的註釋字典

• letter_annotations - 每個字母的註釋字典，值應為與完整序列長度相同的字串、清單或元組。

您通常會使用 Bio.SeqIO 從檔案中讀取序列作為 SeqRecord 物件。但是，您可能需要直接建立自己的 SeqRecord 物件。

請注意，雖然 id 是可選的，但我們強烈建議您為每個記錄提供唯一的 id 字串。如果您希望將序列寫入檔案，這尤其重要。

您可以建立一個「空白」的 SeqRecord 物件，然後稍後填入屬性。

dbxrefs: list[str]

annotations: dict[str, str | int]

property letter_annotations

序列的每個字母註釋字典。

例如，這可以保存 FASTQ 或 QUAL 檔案中使用的品質分數。考慮這個使用 Bio.SeqIO 讀取範例 Solexa 變體 FASTQ 檔案作為 SeqRecord 的範例

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']
>>> 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]

如果切片父 SeqRecord，則 letter_annotations 會自動切片，例如取最後十個鹼基

>>> sub_record = record[-10:]
>>> print("%s %s" % (sub_record.id, sub_record.seq))
slxa_0001_1_0001_01 ACGTNNNNNN
>>> print(sub_record.letter_annotations["solexa_quality"])
[4, 3, 2, 1, 0, -1, -2, -3, -4, -5]

只要長度與 SeqRecord 的序列長度相符，任何 python 序列 (即列表、元組或字串) 都可以記錄在 SeqRecord 的 letter_annotations 字典中。 例如：

>>> len(sub_record.letter_annotations)
1
>>> sub_record.letter_annotations["dummy"] = "abcdefghij"
>>> len(sub_record.letter_annotations)
2

您可以像平常一樣從 letter_annotations 字典中刪除條目

>>> del sub_record.letter_annotations["solexa_quality"]
>>> sub_record.letter_annotations
{'dummy': 'abcdefghij'}

您可以輕鬆地完全清除字典，如下所示

>>> sub_record.letter_annotations = {}
>>> sub_record.letter_annotations
{}

請注意，如果將記錄的序列替換為不同長度的序列，您必須先清除 letter_annotations 字典。

property seq

序列本身，以 Seq 或 MutableSeq 物件表示。

__getitem__(index: int) → str

__getitem__(index: slice) → SeqRecord

回傳子序列或單個字母。

切片操作，例如 `my_record[5:10]`，會回傳一個新的 SeqRecord，其中包含該子序列，並保留一些註釋，如下所示：

• 名稱、ID 和描述會保持不變。

• 任何逐字母的註釋都會被切片以符合請求的子序列。

• 除非使用步幅，否則所有完全落在子序列內的特徵都會被包含進來（它們的位置也會相應調整）。如果您想要保留任何被截斷的特徵（例如 GenBank/EMBL 來源特徵），您必須明確地將它們添加到新的 SeqRecord 中。

• 除了任何分子類型外，新的 SeqRecord 不會使用註釋字典和 dbxrefs 清單，因為它們通常可能不適用於子序列。如果您想要保留它們，您必須明確地將它們複製到新的 SeqRecord 中。

使用整數索引，例如 `my_record[5]`，是從序列中提取該字母的簡寫，等同於 `my_record.seq[5]`。

例如，考慮這個短蛋白及其二級結構，以 PDB 編碼（例如，H 代表 alpha 螺旋），以及一個簡單的組胺酸自磷酸化位點特徵

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> rec = SeqRecord(Seq("MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLAT"
...                     "EMMSEQDGYLAESINKDIEECNAIIEQFIDYLR"),
...                 id="1JOY", name="EnvZ",
...                 description="Homodimeric domain of EnvZ from E. coli")
>>> rec.letter_annotations["secondary_structure"] = "  S  SSSSSSHHHHHTTTHHHHHHHHHHHHHHHHHHHHHHTHHHHHHHHHHHHHHHHHHHHHTT  "
>>> rec.features.append(SeqFeature(SimpleLocation(20, 21),
...                     type = "Site"))

現在讓我們快速看一下完整記錄，

>>> print(rec)
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 1
Per letter annotation for: secondary_structure
Seq('MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLATEMMSEQDGYLAESINKDIEE...YLR')
>>> rec.letter_annotations["secondary_structure"]
'  S  SSSSSSHHHHHTTTHHHHHHHHHHHHHHHHHHHHHHTHHHHHHHHHHHHHHHHHHHHHTT  '
>>> print(rec.features[0].location)
[20:21]

現在讓我們取一個子序列，這裡選擇的是第一個（斷裂的）alpha 螺旋，其中包含組胺酸磷酸化位點

>>> sub = rec[11:41]
>>> print(sub)
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 1
Per letter annotation for: secondary_structure
Seq('RTLLMAGVSHDLRTPLTRIRLATEMMSEQD')
>>> sub.letter_annotations["secondary_structure"]
'HHHHHTTTHHHHHHHHHHHHHHHHHHHHHH'
>>> print(sub.features[0].location)
[9:10]

當然，您也可以省略開始或結束值，例如只取得前十個字母

>>> print(rec[:10])
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 0
Per letter annotation for: secondary_structure
Seq('MAAGVKQLAD')

或是取得最後十個字母

>>> print(rec[-10:])
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 0
Per letter annotation for: secondary_structure
Seq('IIEQFIDYLR')

如果兩者都省略，那麼您會得到原始記錄的副本（儘管缺少註釋和 dbxrefs）

>>> print(rec[:])
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 1
Per letter annotation for: secondary_structure
Seq('MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLATEMMSEQDGYLAESINKDIEE...YLR')

最後，使用簡單的整數索引是直接從序列中提取該字母的簡寫

>>> rec[5]
'K'
>>> rec.seq[5]
'K'

__iter__() → Iterable[Seq | MutableSeq]

迭代序列中的字母。

例如，使用 Bio.SeqIO 讀取蛋白質 FASTA 檔案

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/loveliesbleeding.pro", "fasta")
>>> for amino in record:
...     print(amino)
...     if amino == "L": break
X
A
G
L
>>> print(record.seq[3])
L

這只是直接迭代序列的快捷方式

>>> for amino in record.seq:
...     print(amino)
...     if amino == "L": break
X
A
G
L
>>> print(record.seq[3])
L

請注意，這不會方便與任何逐字母註釋一起迭代。但是，您可以使用 python zip 函數在記錄（或其序列）和相關的逐字母註釋上實現

>>> from Bio import SeqIO
>>> rec = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (rec.id, rec.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(rec.letter_annotations))
['solexa_quality']
>>> for nuc, qual in zip(rec, rec.letter_annotations["solexa_quality"]):
...     if qual > 35:
...         print("%s %i" % (nuc, qual))
A 40
C 39
G 38
T 37
A 36

您可能會同意使用 `zip(rec.seq, ...)` 比使用上面顯示的 `zip(rec, ...)` 更明確。

__contains__(char: str) → bool

實作「in」關鍵字，搜尋序列。

例如：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
>>> "GAATTC" in record
False
>>> "AAA" in record
True

這實質上充當對序列使用「in」的代理

>>> "GAATTC" in record.seq
False
>>> "AAA" in record.seq
True

請注意，您也可以使用 Seq 物件作為查詢：

>>> from Bio.Seq import Seq
>>> Seq("AAA") in record
True

另請參閱 Seq 物件的 `__contains__` 方法。

__bytes__() → bytes

__str__() → str

回傳記錄及其註釋的人類可讀摘要（字串）。

python 內建函數 str 會透過呼叫物件的 `__str__` 方法來運作。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein, small")
>>> print(str(record))
ID: YP_025292.1
Name: HokC
Description: toxic membrane protein, small
Number of features: 0
Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')

在這個例子中，您實際上不需要明確呼叫 str，因為 print 命令會自動執行此操作

>>> print(record)
ID: YP_025292.1
Name: HokC
Description: toxic membrane protein, small
Number of features: 0
Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')

請注意，長序列會被截斷顯示。

__repr__() → str

回傳記錄的簡潔摘要以進行除錯（字串）。

python 內建函數 repr 會透過呼叫物件的 `__repr__` 方法來運作。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> rec = SeqRecord(Seq("MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKAT"
...                     "GEMKEQTEWHRVVLFGKLAEVASEYLRKGSQVYIEGQLRTRKWTDQ"
...                     "SGQDRYTTEVVVNVGGTMQMLGGRQGGGAPAGGNIGGGQPQGGWGQ"
...                     "PQQPQGGNQFSGGAQSRPQQSAPAAPSNEPPMDFDDDIPF"),
...                 id="NP_418483.1", name="b4059",
...                 description="ssDNA-binding protein",
...                 dbxrefs=["ASAP:13298", "GI:16131885", "GeneID:948570"])
>>> print(repr(rec))
SeqRecord(seq=Seq('MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKATGEMKEQTE...IPF'), id='NP_418483.1', name='b4059', description='ssDNA-binding protein', dbxrefs=['ASAP:13298', 'GI:16131885', 'GeneID:948570'])

在 python 提示符號下，您也可以使用這個簡寫

>>> rec
SeqRecord(seq=Seq('MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKATGEMKEQTE...IPF'), id='NP_418483.1', name='b4059', description='ssDNA-binding protein', dbxrefs=['ASAP:13298', 'GI:16131885', 'GeneID:948570'])

請注意，長序列會被截斷顯示。另請注意，任何註釋、letter_annotations 和特徵都不會顯示（因為它們會導致非常長的字串）。

format(format: str) → str

以指定的文件格式回傳記錄的字串。

格式應為 Bio.SeqIO 作為輸出格式支援的小寫字串，它用於將 SeqRecord 轉換為字串。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein")
>>> record.format("fasta")
'>YP_025292.1 toxic membrane protein\nMKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF\n'
>>> print(record.format("fasta"))
>YP_025292.1 toxic membrane protein
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

Python 的 print 函數會自動附加一個新行，這表示在這個例子中會顯示一個空白行。如果您查看字串表示法，您可以看到有一個尾隨新行（顯示為斜線 n），這在寫入檔案或將多個序列字串串聯在一起時非常重要。

請注意，此方法不適用於 Bio.SeqIO 支援的每種可能的文件格式（例如，有些僅適用於多個序列，並且不支援二進位格式）。

__format__(format_spec: str) → str

以指定的文件格式回傳記錄的字串。

此方法支援 Python 的 format() 函數和 f-strings。 format_spec 應為 Bio.SeqIO 作為文字輸出檔案格式支援的小寫字串。請求二進位檔案格式會引發 ValueError。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein")
...
>>> format(record, "fasta")
'>YP_025292.1 toxic membrane protein\nMKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF\n'
>>> print(f"Here is {record.id} in FASTA format:\n{record:fasta}")
Here is YP_025292.1 in FASTA format:
>YP_025292.1 toxic membrane protein
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

另請參閱 SeqRecord 的 format() 方法。

__len__() → int

回傳序列的長度。

例如，使用 Bio.SeqIO 讀取 FASTA 核苷酸檔案

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
>>> len(record)
309
>>> len(record.seq)
309

__lt__(other: Any) → NoReturn

定義小於運算子（未實作）。

__le__(other: Any) → NoReturn

定義小於或等於運算子（未實作）。

__eq__(other: object) → NoReturn

定義等於運算子（未實作）。

__ne__(other: object) → NoReturn

定義不等於運算子（未實作）。

__gt__(other: Any) → NoReturn

定義大於運算子（未實作）。

__ge__(other: Any) → NoReturn

定義大於或等於運算子（未實作）。

__bool__() → bool

此類別實例的布林值 (True)。

此行為是為了向後相容性，因為在加入 `__len__` 方法之前，SeqRecord 總是評估為 True。

請注意，相比之下，如果 Seq 物件的序列長度為零，則會評估為 False。

警告：為了更好地符合 Seq 物件的行為，SeqRecord 未來可能會在其序列長度為零時評估為 False！

__add__(other: SeqRecord | Seq | MutableSeq | str) → SeqRecord

將另一個序列或字串加到此序列。

另一個序列可以是 SeqRecord 物件、Seq 物件（或類似的，例如 MutableSeq）或一般的 Python 字串。如果您加入一般的字串或 Seq（類似）物件，新的 SeqRecord 將僅會把此字串附加到現有的資料。然而，任何逐字母的註釋都將遺失。

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']

>>> new = record + "ACT"
>>> print("%s %s" % (new.id, new.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNNACT
>>> print(list(new.letter_annotations))
[]

新的記錄將嘗試合併註釋，但對於任何模糊之處（例如，不同的名稱），它預設會省略該註釋。

>>> from Bio import SeqIO
>>> with open("GenBank/pBAD30.gb") as handle:
...     plasmid = SeqIO.read(handle, "gb")
>>> print("%s %i" % (plasmid.id, len(plasmid)))
pBAD30 4923

現在，讓我們將質體切割成兩塊，然後將它們以相反的方式重新接合（也就是說，移動此質體的起始點，查看原始檔案中的註釋功能，了解為什麼這個特定的分割點可能會有意義）

>>> left = plasmid[:3765]
>>> right = plasmid[3765:]
>>> new = right + left
>>> print("%s %i" % (new.id, len(new)))
pBAD30 4923
>>> str(new.seq) == str(right.seq + left.seq)
True
>>> len(new.features) == len(left.features) + len(right.features)
True

當我們加入左側和右側的 SeqRecord 物件時，它們的註釋都是一致的，因此所有內容都保留在新 SeqRecord 中。

>>> new.id == left.id == right.id == plasmid.id
True
>>> new.name == left.name == right.name == plasmid.name
True
>>> new.description == plasmid.description
True
>>> new.annotations == left.annotations == right.annotations
True
>>> new.letter_annotations == plasmid.letter_annotations
True
>>> new.dbxrefs == left.dbxrefs == right.dbxrefs
True

然而，我們應該指出，當我們切分 SeqRecord 時，任何 annotations 字典或 dbxrefs 清單中的條目都會遺失。您可以像這樣明確複製它們

>>> new.annotations = plasmid.annotations.copy()
>>> new.dbxrefs = plasmid.dbxrefs[:]

__radd__(other: Seq | MutableSeq | str) → SeqRecord

將另一個序列或字串加到此序列（從左側）。

此方法處理將 Seq 物件（或類似的，例如 MutableSeq）或一般的 Python 字串（在左側）加入到 SeqRecord（在右側）。請參閱 __add__ 方法以取得更多詳細資訊，例如

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']

>>> new = "ACT" + record
>>> print("%s %s" % (new.id, new.seq))
slxa_0001_1_0001_01 ACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(new.letter_annotations))
[]

count(sub, start=None, end=None)

傳回 seq[start:end] 中 sub 的非重疊出現次數。

可選的引數 start 和 end 的解讀方式與切片表示法相同。此方法的行為與 Python 字串的 count 方法相同。

upper() → SeqRecord

傳回序列為大寫的記錄副本。

所有註釋都會保持不變。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("acgtACGT"), id="Test",
...                    description = "Made up for this example")
>>> record.letter_annotations["phred_quality"] = [1, 2, 3, 4, 5, 6, 7, 8]
>>> print(record.upper().format("fastq"))
@Test Made up for this example
ACGTACGT
+
"#$%&'()

當然，還有一個對應的 lower 方法

>>> print(record.lower().format("fastq"))
@Test Made up for this example
acgtacgt
+
"#$%&'()

__annotations__ = {'_per_letter_annotations': '_RestrictedDict', 'annotations': dict[str, typing.Union[str, int]], 'dbxrefs': list[str]}

__hash__ = None

lower() → SeqRecord

傳回序列為小寫的記錄副本。

所有註釋都會保持不變。例如：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/aster.pro", "fasta")
>>> print(record.format("fasta"))
>gi|3298468|dbj|BAA31520.1| SAMIPF
GGHVNPAVTFGAFVGGNITLLRGIVYIIAQLLGSTVACLLLKFVTNDMAVGVFSLSAGVG
VTNALVFEIVMTFGLVYTVYATAIDPKKGSLGTIAPIAIGFIVGANI

>>> print(record.lower().format("fasta"))
>gi|3298468|dbj|BAA31520.1| SAMIPF
gghvnpavtfgafvggnitllrgivyiiaqllgstvaclllkfvtndmavgvfslsagvg
vtnalvfeivmtfglvytvyataidpkkgslgtiapiaigfivgani

為了提供更豐富的註釋範例，

>>> from Bio import SeqIO
>>> old = SeqIO.read("EMBL/TRBG361.embl", "embl")
>>> len(old.features)
3
>>> new = old.lower()
>>> len(old.features) == len(new.features)
True
>>> old.annotations["organism"] == new.annotations["organism"]
True
>>> old.dbxrefs == new.dbxrefs
True

isupper()

如果記錄序列中的所有 ASCII 字元都是大寫，則傳回 True。

如果沒有大小寫字元，則此方法會傳回 False。

islower()

如果記錄序列中的所有 ASCII 字元都是小寫，則傳回 True。

如果沒有大小寫字元，則此方法會傳回 False。

reverse_complement(id: bool = False, name: bool = False, description: bool = False, features: bool = True, annotations: bool = False, letter_annotations: bool = True, dbxrefs: bool = False) → SeqRecord

傳回具有反向互補序列的新 SeqRecord。

預設情況下，新的記錄不會保留序列識別碼、名稱、描述、一般註釋或資料庫交叉參照 - 這些不太可能適用於反向序列。

您可以將傳回記錄的 id、名稱和描述指定為字串，或 True 以保留父項的 id、名稱和描述，或 False 以使用預設值。

您可以指定傳回記錄的 features 為 SeqFeature 物件的清單，或 True 以保留父項的 features，或 False 以省略它們。預設值是保留原始的 features（並調整鏈和位置）。

您也可以將傳回記錄的 annotations 和 letter_annotations 指定為字典、True 以保留父項的 annotations 和 letter_annotations，或 False 以省略它們。預設值是保留原始的 annotations（並反轉字母註釋）。

為了展示前字母註釋會發生什麼情況，請考慮一個範例 Solexa 變體 FASTQ 檔案，其中包含一個條目，我們將其讀取為 SeqRecord

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']
>>> 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]

現在取反向互補，這裡我們明確給出一個新的識別碼（具有後綴的舊識別碼）

>>> rc_record = record.reverse_complement(id=record.id + "_rc")
>>> print("%s %s" % (rc_record.id, rc_record.seq))
slxa_0001_1_0001_01_rc NNNNNNACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT

請注意，逐字母註釋也已被反轉，儘管這可能不適用於所有情況。

>>> print(rc_record.letter_annotations["solexa_quality"])
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]

現在，對於 features，我們需要一個不同的範例。解析 GenBank 檔案可能是取得具有 features 的好範例的最簡單方法…

>>> from Bio import SeqIO
>>> with open("GenBank/pBAD30.gb") as handle:
...     plasmid = SeqIO.read(handle, "gb")
>>> print("%s %i" % (plasmid.id, len(plasmid)))
pBAD30 4923
>>> plasmid.seq
Seq('GCTAGCGGAGTGTATACTGGCTTACTATGTTGGCACTGATGAGGGTGTCAGTGA...ATG')
>>> len(plasmid.features)
13

現在，讓我們取這個整個質體的反向互補

>>> rc_plasmid = plasmid.reverse_complement(id=plasmid.id+"_rc")
>>> print("%s %i" % (rc_plasmid.id, len(rc_plasmid)))
pBAD30_rc 4923
>>> rc_plasmid.seq
Seq('CATGGGCAAATATTATACGCAAGGCGACAAGGTGCTGATGCCGCTGGCGATTCA...AGC')
>>> len(rc_plasmid.features)
13

讓我們比較第一個 CDS feature - 它已從第二個 feature（索引 1）變為倒數第二個 feature（索引 -2），它的鏈已變更，並且位置已切換。

>>> print(plasmid.features[1])
type: CDS
location: [1081:1960](-)
qualifiers:
    Key: label, Value: ['araC']
    Key: note, Value: ['araC regulator of the arabinose BAD promoter']
    Key: vntifkey, Value: ['4']

>>> print(rc_plasmid.features[-2])
type: CDS
location: [2963:3842](+)
qualifiers:
    Key: label, Value: ['araC']
    Key: note, Value: ['araC regulator of the arabinose BAD promoter']
    Key: vntifkey, Value: ['4']

您可以根據質體的長度來檢查這個新的位置

>>> len(plasmid) - 1081
3842
>>> len(plasmid) - 1960
2963

請注意，如果 SeqFeature 註釋包含任何鏈特定的資訊（例如，SNP 的鹼基變更），則不會修改此資訊，並且在反向互補後需要更正。

請注意，嘗試反向互補蛋白質 SeqRecord 會引發例外狀況

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> protein_rec = SeqRecord(Seq("MAIVMGR"), id="Test",
...                         annotations={"molecule_type": "protein"})
>>> protein_rec.reverse_complement()
Traceback (most recent call last):
   ...
ValueError: Proteins do not have complements!

如果您有不含任何 U 鹼基的 RNA，則必須將其註釋為 RNA，否則預設會將其視為 DNA，並將 A 對應到 T

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> rna1 = SeqRecord(Seq("ACG"), id="Test")
>>> rna2 = SeqRecord(Seq("ACG"), id="Test", annotations={"molecule_type": "RNA"})
>>> print(rna1.reverse_complement(id="RC", description="unk").format("fasta"))
>RC unk
CGT

>>> print(rna2.reverse_complement(id="RC", description="RNA").format("fasta"))
>RC RNA
CGU

另請注意，您可以使用 MutableSeq 反向互補 SeqRecord

>>> from Bio.Seq import MutableSeq
>>> from Bio.SeqRecord import SeqRecord
>>> rec = SeqRecord(MutableSeq("ACGT"), id="Test")
>>> rec.seq[0] = "T"
>>> print("%s %s" % (rec.id, rec.seq))
Test TCGT
>>> rc = rec.reverse_complement(id=True)
>>> print("%s %s" % (rc.id, rc.seq))
Test ACGA

translate(table: str = 'Standard', stop_symbol: str = '*', to_stop: bool = False, cds: bool = False, gap: str | None = None, id: bool = False, name: bool = False, description: bool = False, features: bool = False, annotations: bool = False, letter_annotations: bool = False, dbxrefs: bool = False) → SeqRecord

傳回帶有已翻譯序列的新 SeqRecord。

此函式會呼叫 record 的 .seq.translate() 方法（該方法描述了與翻譯相關的引數，例如遺傳密碼表）。

預設情況下，新的 record 不會保留序列識別符、名稱、描述、一般註解或資料庫交叉參考 - 這些不太可能適用於已翻譯的序列。

您可以將傳回記錄的 id、名稱和描述指定為字串，或 True 以保留父項的 id、名稱和描述，或 False 以使用預設值。

您可以使用 SeqFeature 物件的列表指定傳回的 record 的特徵，或使用 False（預設）省略它們。

您也可以將傳回的 record 的註解和 letter_annotations 指定為字典，使用 True 保留父物件的註解（僅限註解），或使用 False（預設）省略它們。

例如，載入 FASTA 基因並進行翻譯：

>>> from Bio import SeqIO
>>> gene_record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
>>> print(gene_record.format("fasta"))
>gi|3176602|gb|U78617.1|LOU78617 Lathyrus odoratus phytochrome A (PHYA) gene, partial cds
CAGGCTGCGCGGTTTCTATTTATGAAGAACAAGGTCCGTATGATAGTTGATTGTCATGCA
AAACATGTGAAGGTTCTTCAAGACGAAAAACTCCCATTTGATTTGACTCTGTGCGGTTCG
ACCTTAAGAGCTCCACATAGTTGCCATTTGCAGTACATGGCTAACATGGATTCAATTGCT
TCATTGGTTATGGCAGTGGTCGTCAATGACAGCGATGAAGATGGAGATAGCCGTGACGCA
GTTCTACCACAAAAGAAAAAGAGACTTTGGGGTTTGGTAGTTTGTCATAACACTACTCCG
AGGTTTGTT

現在翻譯 record，指定新的 ID 和描述：

>>> protein_record = gene_record.translate(table=11,
...                                        id="phya",
...                                        description="translation")
>>> print(protein_record.format("fasta"))
>phya translation
QAARFLFMKNKVRMIVDCHAKHVKVLQDEKLPFDLTLCGSTLRAPHSCHLQYMANMDSIA
SLVMAVVVNDSDEDGDSRDAVLPQKKKRLWGLVVCHNTTPRFV