Para gerar uma nova lista a partir de uma lista (array) cujos elementos são cordas, extraindo apenas os elementos de cordas que satisfazem determinadas condições, ou realizando substituições, conversões, etc., utilizar compreensões de lista.
Após uma breve explicação da compreensão da lista, o conteúdo seguinte é explicado com o código da amostra.
- Extracção com base na inclusão ou não de uma corda específica (correspondência parcial)
- Substituir cadeia específica
- Extrair começando ou não por uma corda específica
- Extrair terminando ou não terminando com um fio específico
- Julgado e extraído por caso
- Converter letras maiúsculas e minúsculas
- Determina se são utilizados caracteres alfabéticos ou numéricos e extrai-os
- Múltiplas condições
- (computador) expressão regular
Note-se que as listas podem armazenar diferentes tipos de dados e são estritamente diferentes das arrays. Se quiser tratar arrays em processos que requerem tamanho de memória e endereços de memória ou processamento numérico de dados grandes, use array (biblioteca padrão) ou NumPy.
- notação de inclusão na lista
- Contém um fio específico (correspondência parcial) Não contém: in
- Substituir cadeia específica
- Começa com uma corda específica {\i} não começa: startswith()
- Termina com uma cadeia de caracteres específica {\i1}não termina: endswith()
- Julgado e extraído por caso
- Converter letras maiúsculas e minúsculas
- Determina se são utilizados caracteres alfabéticos ou numéricos e extrai-os
- Múltiplas condições
- (computador) expressão regular
notação de inclusão na lista
Ao gerar uma nova lista a partir de uma lista, as compreensões da lista são mais simples de escrever do que para loops.
- RELACIONADO:Como utilizar as compreensões da lista Python
[expression for any variable name in iterable object if conditional expression]
Se o elemento só deve ser seleccionado por uma expressão condicional, não é processado por uma expressão, pelo que assume a seguinte forma
[variable name for variable name in original list if conditional expression]
Se a expressão condicional for transformada numa expressão se não condicional, torna-se uma negação, e os elementos que não satisfazem a expressão condicional podem ser extraídos.
Contém um fio específico (correspondência parcial) Não contém: in
Em “cadeia específica na cadeia original”, retorna Verdadeiro se a cadeia original contém a cadeia específica. Esta é uma expressão condicional.
A negação do in é feita com o 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']
Substituir cadeia específica
Se quiser substituir uma cadeia de elementos da lista, utilize o método de cadeia substituir() para cada elemento da notação de compreensão da lista.
Se não houver nenhuma cadeia a ser substituída, não há necessidade de seleccionar o elemento na expressão se condicional porque não será alterada através da aplicação de substituir().
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Se quiser substituir um elemento inteiro que contenha um fio específico, extraia-o e processe-o com o operador ternário. O operador ternário é escrito da seguinte forma.True Value if Conditional Expression else False Value
Não há problema se a expressão parte da notação de compreensão da lista for um operador ternário.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Segue-se um resumo dos resultados, entre parênteses. Se não estiver habituado a utilizar parênteses, poderá ser mais fácil de compreender e evitar erros. Gramaticalmente, não há problema, mesmo que se escreva parênteses.
[('ZZZ' if ('XXX' in s) else s) for s in l]
A utilização de in como condição é confusa com a notação de compreensão de lista in, mas não é difícil se estiver ciente da forma sintáctica de notação de compreensão de lista e operadores ternários.
Começa com uma corda específica {\i} não começa: startswith()
O método de string começa com() retorna verdadeiro se a string começa com a string 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']
Termina com uma cadeia de caracteres específica {\i1}não termina: endswith()
O método de string termina com() retorna verdadeiro se a string termina com a string 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']
Julgado e extraído por caso
Os métodos de cordas isupper(),islower() podem ser usados para determinar se uma corda é toda em maiúsculas ou todas as minúsculas.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
Converter letras maiúsculas e minúsculas
Se quiser converter todos os caracteres para maiúsculas ou minúsculas, utilize os métodos de cadeia superior() e inferior(). Outros métodos incluem capitalize(), que capitaliza apenas a primeira letra, e swapcase(), que troca as letras maiúsculas e minúsculas.
Como no exemplo de substituição acima, utilize o operador ternário se quiser processar apenas elementos que satisfaçam a condição.
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 são utilizados caracteres alfabéticos ou numéricos e extrai-os
Os métodos de cordas isalfa() e isumérica() podem ser usados para determinar se uma corda é toda 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']
Múltiplas condições
A expressão condicional parte das compreensões da lista pode ser condições múltiplas. As condições negativas “não” também podem ser usadas.
Ao utilizar três ou mais expressões condicionais, é mais seguro fechar cada grupo entre parênteses () porque o resultado variará dependendo da ordem.
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']
(computador) expressão regular
As expressões regulares permitem um processamento altamente flexível.
O objecto correspondente devolvido por re.match() quando corresponde é sempre determinado como sendo verdadeiro quando avaliado com uma expressão condicional. Se não corresponder, devolve Nenhum, o que é falso na expressão condicional. Assim, se quiser extrair apenas os elementos que correspondem à expressão regular, basta aplicar re.match() à expressão condicional parte da expressão de compreensão da lista, como anteriormente.
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 substitui a parte correspondente de uma expressão regular, é também útil. Para extrair e substituir apenas os elementos combinados, basta acrescentar “se expressão 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']
