我正在尝试构建一个工具，该工具将有助于简化研究工作，并且似乎需要检测何时在一个列中的数据中增加序列，而在另一列中的asc / desc序列。
有没有一种干净的方法来检查行中是否有序列，而不必编写像这样https://stackoverflow.com/a/52679427/5045375那样遍历行的状态机？编写这样的代码片段将不得不检查一列中的值是否在递增（无间隙），而另一列是asc / desc（无间隙）。我完全能够做到这一点，我只是想知道我的熊猫工具箱中是否缺少某些东西。
这里有一些例子可以说明我的意图，
import pandas as pd
from collections import namedtuple
QUERY_SEGMENT_ID_COLUMN = 'Query Segment Id'
REFERENCE_SEGMENT_ID_COLUMN = 'Reference Segment Id'
def dataframe(data):
columns = [QUERY_SEGMENT_ID_COLUMN, REFERENCE_SEGMENT_ID_COLUMN]
return pd.DataFrame(data, columns=columns)
# No sequence in either column. No results
data_without_pattern = [[1, 2], [7, 0], [3, 6]]
# Sequence in first column, but no sequence in second column. No results
data_with_pseodo_pattern_query = [[1, 2], [2, 0], [3, 6]]
# Sequence in second column, but no sequence in first column. No results
data_with_pseudo_pattern_reference = [[1, 2], [7, 3], [3, 4]]
# Broken sequence in first column, sequence in second column. No results
data_with_pseudo_pattern_query_broken = [[1, 2], [3, 3], [7, 4]]
# Sequence occurs in both columns, asc. Expect results
data_with_pattern_asc = [[1, 2], [2, 3], [3, 4]]
# Sequence occurs in both columns, desc. Expect results
data_with_pattern_desc = [[1, 4], [2, 3], [3, 2]]
# There is a sequence, and some noise. Expect results
data_with_pattern_and_noise = [[1, 0], [1, 4], [1, 2], [1, 3], [2, 3], [3, 4]]
在第一个示例中，没有任何模式
print(dataframe(data_without_pattern))
Query Segment Id Reference Segment Id
0 1 2
1 7 0
2 3 6
第二个示例在查询列中具有升序的ID序列，但在参考列中没有ID的序列，
print(dataframe(data_with_pseodo_pattern_query))
Query Segment Id Reference Segment Id
0 1 2
1 2 0
2 3 6
第三个示例与前面的示例相同，但参考列为。
print(dataframe(data_with_pseudo_pattern_reference))
Query Segment Id Reference Segment Id
0 1 2
1 7 3
2 3 4
在这里，参考列中有一个升序，而查询列中的id也是按升序排列，因此存在间隙，因此不会有结果
print(dataframe(data_with_pseudo_pattern_query_broken))
Query Segment Id Reference Segment Id
0 1 2
1 3 3
2 7 4
这是两个“完美”的示例，其中查询列按升序排列，不间断，而参考列按降序排列。预期结果。
print(dataframe(data_with_pattern_asc))
Query Segment Id Reference Segment Id
0 1 2
1 2 3
2 3 4
print(dataframe(data_with_pattern_desc))
Query Segment Id Reference Segment Id
0 1 4
1 2 3
2 3 2
最终，一个数据不那么干净但仍然存在所需模式的案例
print(dataframe(data_with_pattern_and_noise))
Query Segment Id Reference Segment Id
0 1 0
1 1 4
2 1 2
3 1 3
4 2 3
5 3 4
此最新情况可能需要进一步说明。我的目的是返回类似于q=(1, 3), r=(2, 4)的内容，例如来自各列（而不是索引）的(start, end) 值。
我在考虑是否有可能进行一系列不错的group_by操作，但我看不到树木茂盛。
我认为该问题具有社区价值，因为在有人在多列中的行中查找模式时找不到类似的问题。
编辑：注释中的大小写（@ code-different）
对于数据框，
data_with_multiple_contiguous_sequences = [[1, 1], [2, 2], [3, 3], [0, 4], [1, 5], [2, 6], [3, 7], [4, 8]]
Query Segment Id Reference Segment Id
0 1 1
1 2 2
2 3 3
3 0 4
4 1 5
5 2 6
6 3 7
7 4 8
目标是识别两个序列。意味着我们要产生q1=(1, 3), r1=(1, 3), q2=(0, 4), r2=(4, 8)。
答案 0 :(得分：1)
如果我对您的理解正确，那么您的问题就是孤岛问题的一种变体。每个具有可接受间隙的单调（递增或递减）子序列都将形成一个孤岛。例如，给定一系列s：
s island
-- ------
0 1
0 1
1 1
3 2 # gap > 1, form new island
4 2
2 3 # stop increasing, form new island
1 3
0 3
概括地说：只要当前行和上一行之间的间隔超出[-1，1]范围，就会形成一个新的孤岛。
在Query Segment Id和Reference Segment Id上应用这种差距与岛屿算法：
Query Segment Id Q Island Reference Segment Id R Island Q-R Intersection
---------------- -------- -------------------- -------- ----------------
1 1 1 1 (1, 1)
2 1 2 1 (1, 1)
3 1 3 1 (1, 1)
0 2 4 1 (2, 1)
1 2 5 1 (2, 1)
2 2 6 1 (2, 1)
3 2 7 1 (2, 1)
4 2 8 1 (2, 1)
0 3 9 1 (3, 1)
您正在寻找的q和r范围现在是每个Query Segment Id开头和结尾的Reference Segment Id和Q-R Intersection。最后一个警告：忽略长度为1的交集（如最后一个交集）。
代码：
columns = ['Query Segment Id', 'Reference Segment Id']
df = pd.DataFrame(data_with_multiple_contiguous_sequences, columns=columns)
def get_island(col):
return (~col.diff().between(-1,1)).cumsum()
df[['Q Island', 'R Island']] = df[['Query Segment Id', 'Reference Segment Id']].apply(get_island)
result = df.groupby(['Q Island', 'R Island']) \
.agg(**{
'Q Start': ('Query Segment Id', 'first'),
'Q End': ('Query Segment Id', 'last'),
'R Start': ('Reference Segment Id', 'first'),
'R End': ('Reference Segment Id', 'last'),
'Count': ('Query Segment Id', 'count')
}) \
.replace({'Count': 1}, {'Count': np.nan}) \
.dropna()
result['Q'] = result[['Q Start', 'Q End']].apply(tuple, axis=1)
result['R'] = result[['R Start', 'R End']].apply(tuple, axis=1)
结果：
Q Start Q End R Start R End Count Q R
Q Island R Island
1 1 1 3 1 3 3 (1, 3) (1, 3)
2 1 0 4 4 8 5 (0, 4) (4, 8)