Podzielić ciąg co n-ty znak?

Czy można podzielić ciąg co n-ty znak?

Załóżmy na przykład, że mam ciąg znaków zawierający następujące elementy:

'1234567890'

Jak mogę to wyglądać tak:

['12','34','56','78','90']

>>> line = '1234567890'
>>> n = 2
>>> [line[i:i+n] for i in range(0, len(line), n)]
['12', '34', '56', '78', '90']

Aby być kompletnym, możesz to zrobić za pomocą wyrażenia regularnego:

>>> import re
>>> re.findall('..','1234567890')
['12', '34', '56', '78', '90']

W przypadku nieparzystej liczby znaków możesz to zrobić:

>>> import re
>>> re.findall('..?', '123456789')
['12', '34', '56', '78', '9']

Możesz również wykonać następujące czynności, aby uprościć wyrażenie regularne dla dłuższych fragmentów:

>>> import re
>>> re.findall('.{1,2}', '123456789')
['12', '34', '56', '78', '9']

I możesz użyć, re.finditerjeśli ciąg jest długi, aby wygenerować porcję po porcji.

W tym języku jest już wbudowana funkcja.

>>> from textwrap import wrap
>>> s = '1234567890'
>>> wrap(s, 2)
['12', '34', '56', '78', '90']

Oto, co mówi dokument do zawijania:

>>> help(wrap)
'''
Help on function wrap in module textwrap:

wrap(text, width=70, **kwargs)
    Wrap a single paragraph of text, returning a list of wrapped lines.

    Reformat the single paragraph in 'text' so it fits in lines of no
    more than 'width' columns, and return a list of wrapped lines.  By
    default, tabs in 'text' are expanded with string.expandtabs(), and
    all other whitespace characters (including newline) are converted to
    space.  See TextWrapper class for available keyword args to customize
    wrapping behaviour.
'''

Innym popularnym sposobem grupowania elementów w grupy o długości n:

>>> s = '1234567890'
>>> map(''.join, zip(*[iter(s)]*2))
['12', '34', '56', '78', '90']

Ta metoda pochodzi prosto z dokumentacji dla zip().

Myślę, że jest to krótszy i bardziej czytelny niż wersja itertools:

def split_by_n(seq, n):
    '''A generator to divide a sequence into chunks of n units.'''
    while seq:
        yield seq[:n]
        seq = seq[n:]

print(list(split_by_n('1234567890', 2)))

Podoba mi się to rozwiązanie:

s = '1234567890'
o = []
while s:
    o.append(s[:2])
    s = s[2:]

Używanie narzędzi itertools z PyPI:

>>> from more_itertools import sliced
>>> list(sliced('1234567890', 2))
['12', '34', '56', '78', '90']

Możesz użyć grouper()przepisu z itertools:

Python 2.x:

from itertools import izip_longest    

def grouper(iterable, n, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

Python 3.x:

from itertools import zip_longest

def grouper(iterable, n, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return zip_longest(*args, fillvalue=fillvalue)

Funkcje te są wydajne pod względem pamięci i działają z dowolnymi iteracjami.

Wypróbuj następujący kod:

from itertools import islice

def split_every(n, iterable):
    i = iter(iterable)
    piece = list(islice(i, n))
    while piece:
        yield piece
        piece = list(islice(i, n))

s = '1234567890'
print list(split_every(2, list(s)))

>>> from functools import reduce
>>> from operator import add
>>> from itertools import izip
>>> x = iter('1234567890')
>>> [reduce(add, tup) for tup in izip(x, x)]
['12', '34', '56', '78', '90']
>>> x = iter('1234567890')
>>> [reduce(add, tup) for tup in izip(x, x, x)]
['123', '456', '789']

Spróbuj tego:

s='1234567890'
print([s[idx:idx+2] for idx,val in enumerate(s) if idx%2 == 0])

Wynik:

['12', '34', '56', '78', '90']

Jak zawsze dla tych, którzy kochają jedną wkładkę

n = 2  
line = "this is a line split into n characters"  
line = [line[i * n:i * n+n] for i,blah in enumerate(line[::n])]

Proste rekurencyjne rozwiązanie dla krótkiego łańcucha:

def split(s, n):
    if len(s) < n:
        return []
    else:
        return [s[:n]] + split(s[n:], n)

print(split('1234567890', 2))

Lub w takiej formie:

def split(s, n):
    if len(s) < n:
        return []
    elif len(s) == n:
        return [s]
    else:
        return split(s[:n], n) + split(s[n:], n)

, która bardziej szczegółowo ilustruje typowy wzór dziel i zwyciężaj w podejściu rekurencyjnym (chociaż praktycznie nie jest to konieczne)

Utknąłem w tym samym scenariuszu.

To zadziałało dla mnie

x="1234567890"
n=2
list=[]
for i in range(0,len(x),n):
    list.append(x[i:i+n])
print(list)

Wynik

['12', '34', '56', '78', '90']

more_itertools.slicedzostało wspomniane wcześniej. Oto cztery dodatkowe opcje z more_itertoolsbiblioteki:

s = "1234567890"

["".join(c) for c in mit.grouper(2, s)]

["".join(c) for c in mit.chunked(s, 2)]

["".join(c) for c in mit.windowed(s, 2, step=2)]

["".join(c) for c in  mit.split_after(s, lambda x: int(x) % 2 == 0)]

Każda z tych ostatnich opcji generuje następujące dane wyjściowe:

['12', '34', '56', '78', '90']

Dokumentacja dla omawianych opcji: grouper, chunked, windowed,split_after

Można to osiągnąć za pomocą prostej pętli for.

a = '1234567890a'
result = []

for i in range(0, len(a), 2):
    result.append(a[i : i + 2])
print(result)

Wyjście wygląda następująco: „12”, „34”, „56”, „78”, „90”, „a”]