n 번째 문자마다 문자열을 분할 하시겠습니까?

n 번째 문자마다 문자열을 분할 할 수 있습니까?

예를 들어, 다음을 포함하는 문자열이 있다고 가정하십시오.

'1234567890'

어떻게 이렇게 보일 수 있습니까?

['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']

완료하기 위해 정규식 으로이 작업을 수행 할 수 있습니다.

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

홀수의 문자에 대해 다음을 수행 할 수 있습니다.

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

긴 청크에 대한 정규식을 단순화하기 위해 다음을 수행 할 수도 있습니다.

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

re.finditer문자열이 청크별로 청크를 생성하는 데 긴 경우 사용할 수 있습니다 .

파이썬에는 이미 내장 함수가 있습니다.

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

이것이 랩의 docstring이 말하는 것입니다 :

>>> 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.
'''

요소를 n 길이 그룹으로 그룹화하는 또 다른 일반적인 방법은 다음과 같습니다.

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

이 방법은에 대한 문서에서 직접 제공됩니다 zip().

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)))

나는이 솔루션을 좋아한다 :

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

PyPI에서 더 많은 itertools 사용 :

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

다음에서 grouper()레시피를 사용할 수 있습니다 itertools.

파이썬 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)

파이썬 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)

이 함수는 메모리 효율적이며 모든 이터 러블과 작동합니다.

다음 코드를 시도하십시오.

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']

이 시도:

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

산출:

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

항상 그렇듯이 하나의 라이너를 좋아하는 사람들을 위해

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])]

짧은 문자열을위한 간단한 재귀 솔루션 :

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

print(split('1234567890', 2))

또는 그런 형태로 :

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)

재귀 적 접근 방식에서 일반적인 분할 및 정복 패턴을보다 명확하게 보여줍니다 (실제로이 방법을 수행 할 필요는 없지만)

나는 같은 시나리오에 갇혀 있었다.

이것은 나를 위해 일했다

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

산출

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

more_itertools.sliced전에 언급 되었습니다 . more_itertools라이브러리의 추가 옵션은 다음과 같습니다 .

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)]

후자의 각 옵션은 다음과 같은 출력을 생성합니다.

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

논의 된 옵션에 대한 설명서 : grouper , chunked, windowed,split_after

이것은 간단한 for 루프로 달성 할 수 있습니다.

a = '1234567890a'
result = []

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

출력은 [ '12', '34', '56', '78', '90', 'a']와 같습니다.