Вы можете использовать группа по для группировки последовательных элементов:

from itertools import groupby

a = [0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0]


def groups(lst):
    result = []
    for key, group in groupby(lst):
        if not key:  # is a group of zeroes
            result.extend(list(group))
        else:  # is a group of ones
            count = sum(1 for _ in group)
            if count > 1:  # if more than one
                result.append(count)
                result.extend(0 for _ in range(count - 1))
            else:
                result.append(0)
    return result


print(groups(a))

Вывод

[0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0]

Более короткий (больше питонический?) Следующий:

def groups(lst):
    for key, group in groupby(lst):
        count = sum(1 for _ in group)
        if key and count > 1:
            yield count
        yield from (0 for _ in range(count - key))


print(list(groups(a)))

Вот один из способов использования numpy и понимания списка:

In [23]: a = np.array([0,0,1,1,1,0,0,0,0,1,1,0,0])
In [24]: np.hstack([x.sum() if x[0] == 1 else x for x in np.split(a, np.where(np.diff(a) != 0)[0]+1)])
Out[24]: array([0, 0, 3, 0, 0, 0, 0, 2, 0, 0])

Логика:

1. Найдите ведущие и конечные индексы того, где у вас есть единицы последствий.
2. Разделите свой массив из этих индексов
3. суммируйте те подсписки, у которых есть один, и оставьте подсписки с нулем, как они
4. сгладить результат с помощью np.hstack.

Если вы хотите заменить оставшиеся на 0, выполните следующие действия:

In [28]: np.hstack([[x.sum(), *[0]*(len(x) -1)]  if x[0] == 1 else x for x in np.split(a, np.where(np.diff(a) != 0)[0]+1)])
Out[28]: array([0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0])

[0]*(len(x) -1) создаст для вас ожидаемые нули, и, используя распаковку на месте, вы сможете разместить их рядом с sum(x).

Если вы когда-нибудь хотели использовать чистый Python, вот один из способов использования itertools.groupby:

In [63]: def summ_cons(li):
    ...:     for k,g in groupby(li) :
    ...:            if k:
    ...:               s = sum(g)
    ...:               yield s
    ...:               yield from (0 for _ in range(s-1))
    ...:            yield from g
    ...:            


In [65]: list(summ_cons(a))
Out[65]: [0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0]

используя группа по

from itertools import groupby
a=[0,0,1,1,1,0,0,0,0,1,1,0,0]
lst_of_tuples=[]
for k,v in groupby(a):
    lst_of_tuples.append((k,len(list(v))))
ans=[]
for k,v in lst_of_tuples:
    temp=[v if k==1 else k]
    for i in range(v-1):
        temp.append(0)
    ans=ans+temp

вывод

[0,0,3,0,0,0,0,0,0,2,0,0,0]

Используя модуль itertools:

from itertools import chain, groupby

A = [0,0,1,1,1,0,0,0,0,1,1,0,0]

def get_lst(x):
    values = list(x[1])
    return [len(values)] + [0]*(len(values) - 1) if x[0] else values

res = list(chain.from_iterable(map(get_lst, groupby(A))))

# [0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0]

TL; DR: это дает вам желаемый результат:

import itertools

input = [0,0,1,1,1,0,0,0,0,1,1,0,0]   
result = []

for k, g in itertools.groupby(input):
    if k == 1:
        ll = len(list(g))
        result.extend([ll,] + [0 for _ in range(ll-1)])
    else:
        result.extend(list(g)) 

даст тебе:

[0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0]

объяснение:

itertools имеет функцию groupby для разделения прогонов "одинаковых"

for k, g in itertools.groupby(input):
    print(g, list(k))

даст тебе:

0 [0, 0]
1 [1, 1, 1]
0 [0, 0, 0, 0]
1 [1, 1]
0 [0, 0]

поэтому k - это ключ, элемент входной последовательности, а g - это группа.

таким образом, условия if добавляют либо (в случае 0) серию нулей из ввода, либо длину, если серия единиц плюс нули заполняется на длину 1-серии.

Вот решение, использующее чистые векторизованные операции и без итераций списка:

import numpy as np

data = np.array([0,0,1,1,1,0,0,0,0,1,1,0,0])
output = np.zeros_like(data)

where = np.where(np.diff(data))[0]
vals = where[1::2] - where[::2]
idx = where[::2] + 1

output[idx] = vals
output
# array([0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0])

Используйте pandas, воспользуйтесь преимуществом pandas count подсчитывает значения, отличные от NaN. Создайте NaN с помощью mask, затем сгруппируйте по изменениям значений s.

import pandas as pd
l = [0,0,1,1,1,0,0,0,0,1,1,0,0]
s = pd.Series(l)
g = s.diff().ne(0).cumsum()
s.mask(s==0).groupby(g).transform('count').mask(g.duplicated(), 0).tolist()

Вывод:

[0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0]

Другой вариант без зависимостей:

Старый добрый цикл while с доступом по индексу (иногда быстрее, чем numpy):

def count_same_adjacent_non_zeros(iterable):
  i, x, size = 0, 0, len(iterable)
  while i < size-1:
    if iterable[i] != iterable[i+1]:
      tmp = iterable[x:i+1]
      if not iterable[i] == 0:
        tmp = [len(tmp)] + [0 for _ in range(i-x)]
      for e in tmp: yield e
      x = i + 1
    i += 1
  for e in iterable[x:size]: yield e


print(list(count_same_adjacent_non_zeros(array)))

#=> [0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0]

Работает также с array = [0,0,4,4,4,0,0,0,0,5,5,0,0]