Extraer e substituír elementos que cumpran as condicións dunha lista (matriz) de cadeas en Python

Para xerar unha nova lista a partir dunha lista (matriz) cuxos elementos son cadeas, extraendo só os elementos de cadeas que cumpran determinadas condicións, ou realizando substitucións, conversións, etc., utilice as comprensións de listas.

Despois dunha breve explicación das listas de comprensión, explícanse os seguintes contidos con código de mostra.

• Extracción en función de se se inclúe ou non unha cadea específica (coincidencia parcial)
• Substitúe unha cadea específica
• Extrae comezando ou non cunha cadea específica
• Extrae terminando ou non cunha cadea específica
• Xulgado e extraído por caso
• Converte maiúsculas e minúsculas
• Determina se se utilizan caracteres alfabéticos ou numéricos e extraeos
• Condicións múltiples
• (ordenador) expresión regular

Teña en conta que as listas poden almacenar diferentes tipos de datos e son estrictamente diferentes das matrices. Se quere manexar matrices en procesos que requiren tamaño de memoria e enderezos de memoria ou procesamento numérico de grandes datos, use array (biblioteca estándar) ou NumPy.

notación de inclusión da lista

Ao xerar unha nova lista a partir dunha lista, as comprensións de listas son máis sinxelas de escribir que para os bucles.

• RELACIONADO:Como usar as listas de comprensión de Python

[expression for any variable name in iterable object if conditional expression]

Se o elemento só debe seleccionarse mediante unha expresión condicional, non se procesará mediante unha expresión, polo que toma a seguinte forma

[variable name for variable name in original list if conditional expression]

Se a expresión condicional if se converte nunha expresión condicional if non, convértese nunha negación e pódense extraer elementos que non satisfacen a expresión condicional.

Contén unha cadea específica (coincidencia parcial) \ Non contén:in

En “cadea específica na cadea orixinal”, devolve True se a cadea orixinal contén a cadea específica. Esta é unha expresión condicional.

A negación de in faise con not in.

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']

l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']

Substitúe unha cadea específica

Se quere substituír unha cadea de elementos da lista, use o método de cadea replace() para cada elemento da notación de comprensión da lista.

Se non hai ningunha cadea para substituír, non hai que seleccionar o elemento na expresión condicional if porque non se cambiará aplicando substituír().

l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']

Se queres substituír un elemento enteiro que contén unha cadea específica, extráeo con in e procédeo co operador ternario. O operador ternario escríbese na seguinte forma.
True Value if Conditional Expression else False Value

Está ben se a parte da expresión da notación de comprensión da lista é un operador ternario.

l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']

O seguinte é un resumo dos resultados, entre parénteses. Se non estás afeito a usar parénteses, pode ser máis fácil de entender e evitar erros. Gramaticalmente, non hai problema aínda que escribas entre parénteses.

[('ZZZ' if ('XXX' in s) else s) for s in l]

O uso de in como condición é confuso coa notación de comprensión de lista in, pero non é difícil se coñeces a forma sintáctica da notación de comprensión de lista e os operadores ternarios.

Comeza cunha cadea específica \ non comeza:startswith()

O método de cadea startswith() devolve verdadeiro se a cadea comeza coa cadea especificada no argumento.

l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']

l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']

Remata cunha cadea de caracteres específica \ non remata:endswith()

O método de cadea endswith() devolve verdadeiro se a cadea remata coa cadea especificada no argumento.

l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']

l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']

Xulgado e extraído por caso

Os métodos de cadea isupper(),islower() pódense usar para determinar se unha cadea está en maiúsculas ou en minúsculas.

l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']

Converte maiúsculas e minúsculas

Se queres converter todos os caracteres en maiúsculas ou minúsculas, utiliza os métodos de cadea upper() e lower(). Outros métodos inclúen capitalize(), que escribe só a primeira letra en maiúscula, e swapcase(), que intercambia letras maiúsculas e minúsculas.

Como no exemplo de substitución anterior, use o operador ternario se quere procesar só elementos que cumpran a condición.

l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']

l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']

Determina se se utilizan caracteres alfabéticos ou numéricos e extraeos

Os métodos de cadea isalpha() e isnumeric() pódense usar para determinar se unha cadea é totalmente alfabética, numérica, etc.

l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']

l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']

Condicións múltiples

A parte de expresión condicional das comprensións de listas pode ser varias condicións. Tamén se poden usar condicións negativas “non”.

Cando se usan tres ou máis expresións condicionais, é máis seguro encerrar cada grupo entre parénteses () porque o resultado variará dependendo da orde.

l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']

l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']

(ordenador) expresión regular

As expresións regulares permiten un procesamento moi flexible.

O obxecto de coincidencia devolto por re.match() cando coincide sempre determínase que é verdadeiro cando se avalía cunha expresión condicional. Se non coincide, devolve None, que é falso na expresión condicional. Entón, se queres extraer só os elementos que coinciden coa expresión regular, só tes que aplicar re.match() á parte da expresión condicional da expresión de comprensión da lista como antes.

import re

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']

re.sub(), que substitúe a parte coincidente dunha expresión regular, tamén é útil. Para extraer e substituír só os elementos coincidentes, só tes que engadir “se expresión condicional”.

l_re_sub_all = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']

l_re_sub = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']