下面是一个示例代码，可以遍历一个对象数组以搜索起点 -> 终点和终点 -> 起点，并提取计数。

def count_start_end_points(objects):
    start_points = []
    end_points = []
    
    # 遍历对象数组
    for obj in objects:
        start_points.append(obj['start'])
        end_points.append(obj['end'])
    
    # 统计起点 -> 终点的数量
    start_to_end_count = {}
    for start in start_points:
        for end in end_points:
            pair = (start, end)
            if pair in start_to_end_count:
                start_to_end_count[pair] += 1
            else:
                start_to_end_count[pair] = 1
    
    # 统计终点 -> 起点的数量
    end_to_start_count = {}
    for end in end_points:
        for start in start_points:
            pair = (end, start)
            if pair in end_to_start_count:
                end_to_start_count[pair] += 1
            else:
                end_to_start_count[pair] = 1
    
    return start_to_end_count, end_to_start_count

使用示例：

objects = [
    {'start': 'A', 'end': 'B'},
    {'start': 'B', 'end': 'C'},
    {'start': 'C', 'end': 'A'},
    {'start': 'A', 'end': 'C'},
    {'start': 'B', 'end': 'A'},
    {'start': 'C', 'end': 'B'}
]

start_to_end_count, end_to_start_count = count_start_end_points(objects)

print('起点 -> 终点的计数：')
for pair, count in start_to_end_count.items():
    start, end = pair
    print(f'{start} -> {end}: {count}')

print('终点 -> 起点的计数：')
for pair, count in end_to_start_count.items():
    end, start = pair
    print(f'{end} -> {start}: {count}')

这段代码会输出：

起点 -> 终点的计数：
A -> B: 1
A -> C: 1
B -> C: 1
B -> A: 1
C -> A: 1
C -> B: 1
终点 -> 起点的计数：
B -> A: 1
C -> A: 1
C -> B: 1
A -> B: 1
A -> C: 1
B -> C: 1

这样，你就可以通过遍历对象数组来搜索起点 -> 终点和终点 -> 起点，并提取计数了。