Как объединить или оставить строки в списках в зависимости от условий в Python?

Question

У меня есть три списка:

li1 = ["a", "a", "a", "a", "b", "b", "a", "a", "b"]
li2 = ["a", "a", "a", "b", "a,", "b", "a", "a"]
li3 = ["b", "b", "a", "a", "b"]

Я хочу "нарезать и вставлять" элементы на "b"

Результат должен выглядеть следующим образом:

li1 = ["aaaa", "b", "b", "aa", "b"]
li2 = ["aaa", "b", "a", "b", "aa"]
li3 = ["b", "b", "aa", "b"]

Но я не знаю, как к этому подойти ... пожалуйста, помогите мне!

Answer 1

Я опаздываю, но это еще один вариант:

def join_in(lst, s):
  res, append = [lst[0]], True
  for i, e in enumerate(lst[1:]):
    if res[-1][0] == s and e == s:
      res[-1] += e
      append = False
    else: append = True
    if append: res.append(e)
  return res

Вызов в списки операторов:

print (join_in(li1, 'a')) #=> ["aaaa", "b", "b", "aa", "b"]
print (join_in(li2, 'a')) #=> ["aaa", "b", "a", "b", "aa"]
print (join_in(li3, 'a')) #=> ["b", "b", "aa", "b"]

Возможно позвонить по 'b':

print (join_in(join_in(li3, 'a'), 'b')) #=> ['bb', 'aa', 'b']

Answer 2

Вот функция, которую я написал для выполнения этого:

def Conbine(Li):
    li=[]
    li.append(Li[0])
    Prev=Li[0]
    for i in Li[1:]:
        if not"b"in(i,Prev):li[-1]+=i
        else:
            Prev=i
            li.append(i)
    return li

Вот результат:

>>> Conbine(["a", "a", "a", "a", "b", "b", "a", "a", "b"])

['aaaa', 'b', 'b', 'aa', 'b']
>>> Conbine(["a", "a", "a", "b", "a,", "b", "a", "a"])

['aaa', 'b', 'a,', 'b', 'aa']
>>> Conbine(["b", "b", "a", "a", "b"])

['b', 'b', 'aa', 'b']

Здесь уже есть много ответов, но я надеюсь, что это помогло.

Answer 3

Я не понимаю, почему все ответы выглядят сложными для этого.Я что-то пропустил?

li1 = ['a', 'a', 'a', 'b', 'b', 'a', 'a', 'b']
result = []
for e in li1:
    if result and e != 'b' != result[-1]:
        result[-1] += e
    else:
        result.append(e)
print(result)   

Отпечатки

['aaa', 'b', 'b', 'aa', 'b']

Держите это простым и глупым.Читаемость имеет значение.

Answer 4

Вы можете использовать itertools.groupby, разделяя логику на 3 части:

1. Группируйте по равенству с вашей строкой-разделителем.
2. Создайте итерируемый списокв зависимости от условия, определенного в ключе groupby.
3. Используйте itertools.chain.from_iterable, чтобы сгладить итерируемые списки.

Вот демонстрация.

from itertools import chain, groupby

def sep_by_val(L, k='b'):
    grouper = groupby(L, key=lambda x: x==k)
    gen_of_lst = ([''.join(j)] if not i else list(j) for i, j in grouper)
    return list(chain.from_iterable(gen_of_lst))

sep_by_val(li1)  # ['aaaa', 'b', 'b', 'aa', 'b']
sep_by_val(li2)  # ['aaa', 'b', 'a,', 'b', 'aa']
sep_by_val(li3)  # ['b', 'b', 'aa', 'b']

Answer 5

Itertools и Yield from - отличные конструкции Python, но сложные в освоении.Что-то более простое, например, со сдвигом и разбиением строк.

result = []

while len(li1) > 0:
    split = ''.join(li1).partition('b')
    before, part, after = split
    if before:
        result.extend( before.split() )
    if part:
        result.append(part)
    li1 = after.split()
print(result)

Answer 6

Используйте itertools.groupby.

Если вы хотите присоединиться к группам , а не , принадлежащим определенной клавише

from itertools import groupby

def join_except_key(iterable, key='b'):
    groups = groupby(iterable)
    for k, group in groups:
        if k != key:
            yield ''.join(group) # more general: ''.join(map(str, group))
        else:
            yield from group

Демо:

>>> li1 = ["a", "a", "a", "a", "b", "b", "a", "a", "b", "c", "c", "b", "c", "c"]
>>> list(join_except_key(li1))
['aaaa', 'b', 'b', 'aa', 'b', 'cc', 'b', 'cc']

Если вы хотите присоединиться к группам, принадлежащим к определенному ключу

from itertools import groupby

def join_by_key(iterable, key='a'):
    groups = groupby(iterable)
    for k, group in groups:
        if k == key:
            yield ''.join(group) # more general: ''.join(map(str, group))
        else:
            yield from group

Демо:

>>> li1 = ["a", "a", "a", "a", "b", "b", "a", "a", "b", "c", "c", "b", "c", "c"]
>>> list(join_by_key(li1))
['aaaa', 'b', 'b', 'aa', 'b', 'c', 'c', 'b', 'c', 'c']

Подробности о том, что groupby производит (не генераторный подход для join_except_key)

>>> li1 = ["a", "a", "a", "a", "b", "b", "a", "a", "b", "c", "c", "b", "c", "c"]
>>> groups = [(k, list(group)) for k, group in groupby(li1)]
>>> groups
[('a', ['a', 'a', 'a', 'a']),
 ('b', ['b', 'b']),
 ('a', ['a', 'a']),
 ('b', ['b']),
 ('c', ['c', 'c']),
 ('b', ['b']),
 ('c', ['c', 'c'])]
>>>
>>> result = []
>>> for k, group in groups:
...:    if k != 'b':
...:        result.append(''.join(group))
...:    else:
...:        result.extend(group)
...:
>>> result
['aaaa', 'b', 'b', 'aa', 'b', 'cc', 'b', 'cc']

Понимание списка groups = [... во второй строке было необходимо только для проверки элементовоперация группировки, она отлично работает только с groups = groupby(li1).