dividir una cadena en mayúsculas

Question

Cuál es la forma Pythonic para dividir una cadena antes de las ocurrencias de un determinado conjunto de caracteres?

Por ejemplo, yo desea dividir 'TheLongAndWindingRoad' en cualquier ocurrencia de una letra mayúscula (posiblemente excepto el primero), y obtener ['The', 'Long', 'And', 'Winding', 'Road'].

Editar: También se debe dividir ocurrencias individuales, es decir de 'ABC' Me gustaría obtener ['A', 'B', 'C'].

Answer 1

Por desgracia, no es posible split on a zero-width match en Python. Pero se puede usar re.findall lugar:

>>> import re 
>>> re.findall('[A-Z][^A-Z]*', 'TheLongAndWindingRoad') 
['The', 'Long', 'And', 'Winding', 'Road'] 
>>> re.findall('[A-Z][^A-Z]*', 'ABC') 
['A', 'B', 'C'] 

Answer 2

import re 
filter(None, re.split("([A-Z][^A-Z]*)", "TheLongAndWindingRoad")) 

o

[s for s in re.split("([A-Z][^A-Z]*)", "TheLongAndWindingRoad") if s] 

Answer 3

>>> import re 
>>> re.findall('[A-Z][a-z]*', 'TheLongAndWindingRoad') 
['The', 'Long', 'And', 'Winding', 'Road'] 

>>> re.findall('[A-Z][a-z]*', 'SplitAString') 
['Split', 'A', 'String'] 

>>> re.findall('[A-Z][a-z]*', 'ABC') 
['A', 'B', 'C'] 

Si desea "It'sATest" para dividir a ["It's", 'A', 'Test'] cambio del rexeg a "[A-Z][a-z']*"

Answer 4

solución alternativa (si no me gustan las expresiones explícitas explícitas):

s = 'TheLongAndWindingRoad' 

pos = [i for i,e in enumerate(s) if e.isupper()] 

parts = [] 
for j in xrange(len(pos)): 
    try: 
     parts.append(s[pos[j]:pos[j+1]]) 
    except IndexError: 
     parts.append(s[pos[j]:]) 

print parts 

Answer 5

Una variación en @ChristopheD 's solución

s = 'TheLongAndWindingRoad' 

pos = [i for i,e in enumerate(s+'A') if e.isupper()] 
parts = [s[pos[j]:pos[j+1]] for j in xrange(len(pos)-1)] 

print parts 

Answer 6

Aquí es una solución regex alternativa. El problema se puede reprased como "¿Cómo se inserta un espacio antes de cada letra mayúscula, antes de hacer la división":

>>> s = "TheLongAndWindingRoad ABC A123B45" 
>>> re.sub(r"([A-Z])", r" \1", s).split() 
['The', 'Long', 'And', 'Winding', 'Road', 'A', 'B', 'C', 'A123', 'B45'] 

Esto tiene la ventaja de conservar todos los caracteres no está en blanco, lo que la mayoría de las otras soluciones no lo hacen.

Answer 7

src = 'TheLongAndWindingRoad' 
glue = ' ' 

result = ''.join(glue + x if x.isupper() else x for x in src).strip(glue).split(glue) 

Answer 8

Una forma alternativa sin necesidad de utilizar expresiones regulares o enumerar:

word = 'TheLongAndWindingRoad' 
list = [x for x in word] 

for char in list: 
    if char != list[0] and char.isupper(): 
     list[list.index(char)] = ' ' + char 

fin_list = ''.join(list).split(' ') 

Creo que es más clara y sencilla y sin encadenar demasiados métodos o el uso de una lista por comprensión largo que puede ser difícil de leer.

Answer 9

Una forma alternativa utilizando enumerate y isupper()

Código:

strs = 'TheLongAndWindingRoad' 
ind =0 
count =0 
new_lst=[] 
for index, val in enumerate(strs[1:],1): 
    if val.isupper(): 
     new_lst.append(strs[ind:index]) 
     ind=index 
if ind<len(strs): 
    new_lst.append(strs[ind:]) 
print new_lst 

Salida:

['The', 'Long', 'And', 'Winding', 'Road'] 

Answer 10

otro sin expresiones regulares y la capacidad de mantener mayúsculas contigua si se desea

def split_on_uppercase(s, keep_contiguous=False): 
    """ 

    Args: 
     s (str): string 
     keep_contiguous (bool): flag to indicate we want to 
           keep contiguous uppercase chars together 

    Returns: 

    """ 

    string_length = len(s) 
    is_lower_around = (lambda: s[i-1].islower() or 
         string_length > (i + 1) and s[i + 1].islower()) 

    start = 0 
    parts = [] 
    for i in range(1, string_length): 
     if s[i].isupper() and (not keep_contiguous or is_lower_around()): 
      parts.append(s[start: i]) 
      start = i 
    parts.append(s[start:]) 

    return parts 

>>> split_on_uppercase('theLongWindingRoad') 
['the', 'Long', 'Winding', 'Road'] 
>>> split_on_uppercase('TheLongWindingRoad') 
['The', 'Long', 'Winding', 'Road'] 
>>> split_on_uppercase('TheLongWINDINGRoadT', True) 
['The', 'Long', 'WINDING', 'Road', 'T'] 
>>> split_on_uppercase('ABC') 
['A', 'B', 'C'] 
>>> split_on_uppercase('ABCD', True) 
['ABCD'] 
>>> split_on_uppercase('') 
[''] 
>>> split_on_uppercase('hello world') 
['hello world'] 

Answer 11

Esto es posible con la herramienta more_itertools.split_before.

import more_itertools as mit 

iterable = "TheLongAndWindingRoad" 
[ "".join(i) for i in mit.split_before(iterable, lambda s: s.isupper())] 
# ['The', 'Long', 'And', 'Winding', 'Road'] 

También debe dividir ocurrencias individuales, es decir, desde 'ABC' que me gustaría obtener ['A', 'B', 'C'].

iterable = "ABC" 
[ "".join(i) for i in mit.split_before(iterable, lambda s: s.isupper())] 
# ['A', 'B', 'C'] 

more_itertools es un paquete de terceros con más de 60 herramientas útiles, incluyendo implementaciones para todos los originales itertools recipes, que evite su aplicación manual.