remove - python string split




Dividir string a cada enésimo caractere? (14)

Apenas para ser completo, você pode fazer isso com um regex:

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

Como apontado no comentário, você pode fazer isso:

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

Você também pode fazer o seguinte para simplificar o regex para partes mais longas:

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

E você pode usar re.finditer se a string for longa para gerar chunk por pedaço.

É possível dividir uma string python a cada enésimo caractere?

Por exemplo, suponha que eu tenha uma string contendo o seguinte:

'1234567890'

Como posso fazer com que seja assim:

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

Aqui está outra solução para um caso mais geral em que os pedaços não são de igual comprimento. Se o comprimento for 0, toda a parte restante será retornada.

data é a sequência a ser dividida; fieldsize é uma tupla com a lista do tamanho do campo.

def fieldsplit(data=None, fieldsize=()):
    tmpl=[];
    for pp in fieldsize:
        if(pp>0):
            tmpl.append(line[:pp]);
            line=line[pp:];
        else:
            tmpl.append(line);
            break;
    return tuple(tmpl);

Eu acho que isso é mais curto e mais legível do que a versão do 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)))

Eu estou usando isso:

list(''.join(s) for s in zip(my_str[::2], my_str[1::2]))

ou você pode usar qualquer outro número n vez de 2 .


Eu sei que esta pergunta é antiga, mas este é o caminho mais curto para fazer isso eu estou ciente de:

def split_every_n(S, n):
  return [S[i*n:(i+1)*n] for i in range(len(S) / n)]

Isso, entretanto, pressupõe que o comprimento da sua string é um múltiplo de n. Caso contrário, você teria que preenchê-lo.


Eu tenho esse código que eu uso sempre que preciso fazer isso:

def split_string(n, st):
    lst = [""]
    for i in str(st):
        l = len(lst) - 1
        if len(lst[l]) < n: 
            lst[l] += i
        else:
            lst += [i]
    return lst

print(split_string(3, "test_string."))

Onde:

  • n é o tamanho de cada item da lista
  • st é a string a ser dividida
  • lst é a versão da lista de st
  • i é o personagem atual sendo usado em st
  • l é o tamanho do último item da lista

Outra maneira comum de agrupar elementos em grupos de comprimento n:

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

Esse método vem direto dos documentos para zip() .


Spooky one - tentou inventar mais uma resposta:

def split(s, chunk_size):
    a = zip(*[s[i::chunk_size] for i in range(chunk_size)])
    return [''.join(t) for t in a]

print(split('1234567890', 1))
print(split('1234567890', 2))
print(split('1234567890', 3))

Fora

['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
['12', '34', '56', '78', '90']
['123', '456', '789']

Tente o seguinte código:

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

Uma possibilidade é usar expressões regulares:

import re
re.findall("\w{3}", your_string)

Usando more-itertools do PyPI:

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

Você pode usar a receita de grouper() do 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)

Essas funções são eficientes em termos de memória e funcionam com quaisquer iteráveis.


def split(s, n):
  """
  Split string every nth character

  Parameters
  ----------
  s: string
  n: value of nth
  """
  new_list = []
  for i in range(0, len(s), n):
    new_list.append(s[i:i+n])
  return new_list

print(split('1234567890', 2))

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




python