skbio.sequence.Sequence¶

class skbio.sequence.Sequence(sequence, metadata=None, positional_metadata=None, interval_metadata=None, lowercase=False)[源代码]¶

存储通用序列数据和可选的关联元数据。

Sequence 对象不强制使用字母表或语法，因此是存储序列数据的最通用的对象。 Sequence 物体不一定代表生物序列。例如， Sequence 可用于表示多序列对齐中的位置。子类 DNA ， RNA 和 Protein 强制IUPAC字符集 [1] 为每种分子类型提供特定操作。

Sequence 对象由底层序列数据以及可选元数据和位置元数据组成。底层序列是不可变的，而metdata和位置元数据是可变的。

参数:

sequence (str, Sequence, or 1D np.ndarray (np.uint8 or '|S1')) -- 表示序列本身的字符。
metadata (dict, optional) -- 应用于整个序列的任意元数据。一份浅显的 dict 将被制作（详见下面的示例部分）。
positional_metadata (pd.DataFrame consumable, optional) -- 任意每字符元数据（例如，序列读取质量分数）。必须能够直接传递给 pd.DataFrame 建造师。每个元数据列的长度必须与 sequence . 如有必要，将生成位置元数据的浅拷贝（有关详细信息，请参阅下面的示例部分）。
interval_metadata (IntervalMetadata) -- 应用于序列中的区间来存储区间特征的任意元数据（如序列上的基因、ncRNA）。
lowercase (bool or str, optional) -- 如果 True ，小写序列字符将转换为大写字符。如果 False ，不会转换任何字符。如果是str，它将被视为对象的位置元数据的键。将转换为大写和小写字符 True 值将存储在键下位置元数据的布尔数组中。

参见

DNA, RNA, Protein

引用

示例

>>> from pprint import pprint
>>> from skbio import Sequence
>>> from skbio.metadata import IntervalMetadata

创建序列：

创建没有任何元数据的序列：

>>> seq = Sequence('GGUCGUGAAGGA')
>>> seq
Sequence
---------------
Stats:
    length: 12
---------------
0 GGUCGUGAAG GA

使用元数据和位置元数据创建序列：

>>> metadata = {'authors': ['Alice'], 'desc':'seq desc', 'id':'seq-id'}
>>> positional_metadata = {'exons': [True, True, False, True],
...                        'quality': [3, 3, 4, 10]}
>>> interval_metadata = IntervalMetadata(4)
>>> interval = interval_metadata.add([(1, 3)], metadata={'gene': 'sagA'})
>>> seq = Sequence('ACGT', metadata=metadata,
...                positional_metadata=positional_metadata,
...                interval_metadata=interval_metadata)
>>> seq
Sequence
-----------------------------
Metadata:
    'authors': <class 'list'>
    'desc': 'seq desc'
    'id': 'seq-id'
Positional metadata:
    'exons': <dtype: bool>
    'quality': <dtype: int64>
Interval metadata:
    1 interval feature
Stats:
    length: 4
-----------------------------
0 ACGT

正在检索基础序列数据：

检索基础序列：

>>> seq.values 
array([b'A', b'C', b'G', b'T'],
      dtype='|S1')

基本序列不可变：

>>> values = np.array([b'T', b'C', b'G', b'A'], dtype='|S1')
>>> seq.values = values 
Traceback (most recent call last):
    ...
AttributeError: can't set attribute

>>> seq.values[0] = b'T'
Traceback (most recent call last):
    ...
ValueError: assignment destination is read-only

正在检索序列元数据：

检索元数据：

>>> pprint(seq.metadata) # using pprint to display dict in sorted order
{'authors': ['Alice'], 'desc': 'seq desc', 'id': 'seq-id'}

检索位置元数据：

>>> seq.positional_metadata
   exons  quality
0   True        3
1   True        3
2  False        4
3   True       10

检索间隔元数据：

>>> seq.interval_metadata   
1 interval feature
------------------
Interval(interval_metadata=<...>, bounds=[(1, 3)], fuzzy=[(False, False)], metadata={'gene': 'sagA'})

正在更新序列元数据：

警告

请注意 metadata 和 positional_metadata 是为了表现。由于没有进行深度复制，所以对存储为元数据的可变Python对象所做的更改可能会影响其他对象的元数据 Sequence 对象或共享对该对象的引用的任何其他对象。下面的例子说明了这种行为。

首先，让我们创建一个序列并更新其元数据：

>>> metadata = {'id':'seq-id', 'desc':'seq desc', 'authors': ['Alice']}
>>> seq = Sequence('ACGT', metadata=metadata)
>>> seq.metadata['id'] = 'new-id'
>>> seq.metadata['pubmed'] = 12345
>>> pprint(seq.metadata)
{'authors': ['Alice'], 'desc': 'seq desc', 'id': 'new-id', 'pubmed': 12345}

注意原始元数据字典（存储在变量中 metadata )没有因为做了一个浅拷贝而改变：

>>> pprint(metadata)
{'authors': ['Alice'], 'desc': 'seq desc', 'id': 'seq-id'}
>>> seq.metadata == metadata
False

但是请注意，由于浅的已复制，对可变对象的更新也将更改原始元数据字典：

>>> seq.metadata['authors'].append('Bob')
>>> seq.metadata['authors']
['Alice', 'Bob']
>>> metadata['authors']
['Alice', 'Bob']

操作从另一个序列派生的序列时，也可能发生此行为：

>>> subseq = seq[1:3]
>>> subseq
Sequence
-----------------------------
Metadata:
    'authors': <class 'list'>
    'desc': 'seq desc'
    'id': 'new-id'
    'pubmed': 12345
Stats:
    length: 2
-----------------------------
0 CG
>>> pprint(subseq.metadata)
{'authors': ['Alice', 'Bob'],
 'desc': 'seq desc',
 'id': 'new-id',
 'pubmed': 12345}

子序列继承了其父序列的元数据。如果更新子序列的作者列表，则会看到父序列和原始元数据字典中传播的更改：

>>> subseq.metadata['authors'].append('Carol')
>>> subseq.metadata['authors']
['Alice', 'Bob', 'Carol']
>>> seq.metadata['authors']
['Alice', 'Bob', 'Carol']
>>> metadata['authors']
['Alice', 'Bob', 'Carol']

更新位置元数据的行为类似。让我们用已经存储在 pd.DataFrame ：

>>> positional_metadata = pd.DataFrame(
...     {'list': [[], [], [], []], 'quality': [3, 3, 4, 10]})
>>> seq = Sequence('ACGT', positional_metadata=positional_metadata)
>>> seq
Sequence
-----------------------------
Positional metadata:
    'list': <dtype: object>
    'quality': <dtype: int64>
Stats:
    length: 4
-----------------------------
0 ACGT
>>> seq.positional_metadata
  list  quality
0   []        3
1   []        3
2   []        4
3   []       10

现在，让我们通过添加新列并更改另一列中的值来更新序列的位置元数据：

>>> seq.positional_metadata['gaps'] = [False, False, False, False]
>>> seq.positional_metadata.loc[0, 'quality'] = 999
>>> seq.positional_metadata
  list  quality   gaps
0   []      999  False
1   []        3  False
2   []        4  False
3   []       10  False

注意原始位置元数据（存储在变量中 positional_metadata )没有因为做了一个浅拷贝而改变：

>>> positional_metadata
  list  quality
0   []        3
1   []        3
2   []        4
3   []       10
>>> seq.positional_metadata.equals(positional_metadata)
False

接下来，让我们创建一个从另一个序列派生的序列：

>>> subseq = seq[1:3]
>>> subseq
Sequence
-----------------------------
Positional metadata:
    'list': <dtype: object>
    'quality': <dtype: int64>
    'gaps': <dtype: bool>
Stats:
    length: 2
-----------------------------
0 CG
>>> subseq.positional_metadata
  list  quality   gaps
0   []        3  False
1   []        4  False

如上所述的元数据，因为只有浅的复制了位置元数据，对可变对象的更新也将更改父序列的位置元数据和原始位置元数据 pd.DataFrame ：

>>> subseq.positional_metadata.loc[0, 'list'].append('item')
>>> subseq.positional_metadata
     list  quality   gaps
0  [item]        3  False
1      []        4  False
>>> seq.positional_metadata
     list  quality   gaps
0      []      999  False
1  [item]        3  False
2      []        4  False
3      []       10  False
>>> positional_metadata
     list  quality
0      []        3
1  [item]        3
2      []        4
3      []       10

也可以更新间隔元数据。让我们重新创建一个 Sequence 首先包含间隔元数据的对象：

>>> seq = Sequence('ACGT')
>>> interval = seq.interval_metadata.add(
...     [(1, 3)], metadata={'gene': 'foo'})

您可以直接在 Interval 对象：

>>> interval  
Interval(interval_metadata=<...>, bounds=[(1, 3)], fuzzy=[(False, False)], metadata={'gene': 'foo'})
>>> interval.bounds = [(0, 2)]
>>> interval  
Interval(interval_metadata=<...>, bounds=[(0, 2)], fuzzy=[(False, False)], metadata={'gene': 'foo'})

您还可以查询并获取感兴趣的间隔特征，然后进行修改：

>>> intervals = list(seq.interval_metadata.query(metadata={'gene': 'foo'}))
>>> intervals[0].fuzzy = [(True, False)]
>>> print(intervals[0])  
Interval(interval_metadata=<...>, bounds=[(0, 2)], fuzzy=[(True, False)], metadata={'gene': 'foo'})

属性

`default_write_format`
`interval_metadata`	`IntervalMetadata` 包含间隔功能信息的对象。
`metadata`	`dict` 包含应用于整个对象的元数据。
`observed_chars`	序列中观察到的字符集。
`positional_metadata`	`pd.DataFrame` 包含沿轴的元数据。
`values`	包含基础序列字符的数组。

内嵌函数

`__bool__` \()	返回序列的真值（真值）。
`__contains__` \(子序列)	确定此序列中是否包含子序列。
`__copy__` \()	返回此序列的浅副本。
`__deepcopy__` \(备忘录)	返回此序列的深层副本。
`__eq__` (其他)	确定这个序列是否等于另一个序列。
`__ge__`(value, /)	返回self>=值。
`__getitem__` \(可编入索引的)	把这个序列切片。
`__getstate__` \()	泡菜的帮手。
`__gt__`(value, /)	返回self>值。
`__iter__` \()	在这个序列中迭代位置。
`__le__`(value, /)	返回self<=value。
`__len__` \()	返回此序列中的字符数。
`__lt__`(value, /)	返回self<value。
`__ne__` (其他)	确定这个序列是否与另一个序列不相等。
`__reversed__` \()	以相反的顺序重复这个序列中的位置。
`__str__` \()	以字符串形式返回序列字符。

方法

`concat`(sequences[, how])	连接的iterable `Sequence` 物体。
`count`(subsequence[, start, end])	计算此序列中子序列的出现次数。
`distance`(other[, metric])	计算到另一个序列的距离。
`find_with_regex`(regex[, ignore])	为正则表达式匹配的模式生成切片。
`frequencies`([chars, relative])	计算序列中字符的频率。
`has_interval_metadata` \()	确定对象是否具有间隔元数据。
`has_metadata` \()	确定对象是否具有元数据。
`has_positional_metadata` \()	确定对象是否具有位置元数据。
`index`(subsequence[, start, end])	找到序列中子序列首先出现的位置。
`iter_contiguous`(included[, min_length, invert])	生成连续的子序列基于 included .
`iter_kmers`(k[, overlap])	生成kmers长度 k 从这个序列。
`kmer_frequencies`(k[, overlap, relative])	返回字长计数 k 从这个序列。
`lowercase` \(小写)	返回序列的区分大小写的字符串表示形式。
`match_frequency`(other[, relative])	返回两个序列之间相同的位置计数。
`matches` (其他)	找到与其他序列匹配的位置。
`mismatch_frequency`(other[, relative])	返回两个序列之间不同的位置计数。
`mismatches` (其他)	查找与其他序列不匹配的位置。
`read`(file[, format])	创建新的 `Sequence` 实例。
`replace`(where, character)	将此序列中的值替换为其他字符。
`write`(file[, format])	写一个实例 `Sequence` 一个文件。