Compreensões e geradores

Para obter os quadrados dos números positivos, percorres uma coleção, selecionas valores e transformas cada selecionado. Um ciclo escreve essas decisões em vários passos, enquanto uma compreensão junta-as numa expressão que constrói outra lista.

Compreensões de listas

A forma [expressao for x in xs if condicao] percorre xs, verifica a condição e acrescenta o valor da expressão apenas nos casos aceites.

valores = [-2, 0, 3, 4]
quadrados = [x * x for x in valores if x > 0]
print(quadrados)
print(valores)
print(["par" if x % 2 == 0 else "ímpar" for x in range(4)])

O filtro retira -2 e 0 e a transformação calcula 9 e 16, por isso o resultado tem duas posições. Na expressão a if condicao else b, o resultado é a quando a condição é verdadeira e b caso contrário; este if ... else escolhe o valor de cada elemento sem filtrar entradas, por isso o último exemplo conserva quatro posições.

A compreensão equivale a este ciclo:

quadrados = []
for x in valores:
    if x > 0:
        quadrados.append(x * x)

A compreensão constrói uma lista nova, mas isso não garante ausência de efeitos. Com xs = [[1], [2]], [linha.append(9) for linha in xs] altera xs para [[1, 9], [2, 9]] e produz [None, None]: cada chamada a append devolve None.

Usa a expressão para calcular valores novos. Para vários estados, validações ou efeitos, um ciclo pode mostrar melhor os passos.

Percursos aninhados

As cláusulas for seguem a mesma ordem dos ciclos correspondentes. Em [(i, j) for i in range(2) for j in range(3)], o i fica fixo enquanto j percorre 0, 1 e 2. O resultado tem seis pares: (0, 0), (0, 1), (0, 2), (1, 0), (1, 1) e (1, 2).

matriz = [[1, 2], [3, 4]]
plana = [valor for linha in matriz for valor in linha]
print(plana)

A saída é [1, 2, 3, 4]. Este código remove um nível de listas, não qualquer profundidade. Para estruturas com profundidade variável, usa a decomposição recursiva da lição de recursão.

Também podes criar conjuntos com {x * x for x in valores} e dicionários com {nome: len(nome) for nome in nomes}. Um conjunto elimina resultados repetidos. Num dicionário, uma chave repetida fica com o último valor produzido.

Pares de posições e fronteiras

Para comparar reservas duas a duas, percorremos i e só depois j > i. Assim não comparamos uma reserva consigo própria nem repetimos o par ao contrário. Para três posições, os pares são (0, 1), (0, 2) e (1, 2).

Uma reserva (inicio, fim) pode ocupar o intervalo semiaberto $[inicio,fim[$: inclui o início e exclui o fim. Exigimos inicio < fim. Duas reservas têm uma parte comum quando o maior início é estritamente menor que o menor fim:

max(inicio_a, inicio_b) < min(fim_a, fim_b)

As reservas (9, 11) e (11, 12) apenas se tocam e são compatíveis. Com (10, 12), a primeira partilha o intervalo $[10,11[$ e há conflito. Se ambos os extremos fossem incluídos, o contacto num extremo já contaria como interseção. A desigualdade depende desta convenção, não só dos números.

Iteráveis e iteradores

Um iterável permite obter um percurso; listas e strings são exemplos. Um iterador conserva a posição de um percurso e produz o próximo valor com next. iter(xs) cria um iterador e next(it) avança-o. Quando esgota, lança StopIteration, que for trata para terminar.

Uma lista permite começar um novo percurso. Um iterador esgotado não volta ao início:

it = iter([1, 2])
print(next(it))
print(list(it))
print(list(it))

A saída é 1, depois [2] e depois []; esta diferença de comportamento reaparece em map, filter e nos geradores.

Geradores e yield

Uma expressão (x * x for x in range(4)) cria um gerador, que produz valores quando são pedidos em vez de guardar logo uma lista.

quadrados = (x * x for x in range(4))
print(next(quadrados))
print(list(quadrados))
print(list(quadrados))

def contagem(n):
    while n > 0:
        yield n
        n -= 1

print(list(contagem(3)))

next retira o zero e a primeira conversão em lista consome 1, 4 e 9, pelo que a segunda recebe uma sequência já esgotada.

Na função contagem, yield entrega um valor e suspende a execução; o próximo pedido retoma depois dessa instrução, conservando os nomes locais. Chamar contagem(3) cria o gerador, mas o corpo só começa no primeiro pedido, e return termina o gerador sem produzir mais valores.

Para seguir essa suspensão, considera g = contagem(3). Ao criar o gerador, o corpo ainda não correu. A tabela acompanha os pedidos seguintes; a última coluna mostra o valor local de n quando suspende ou termina:

No primeiro pedido, o teste 3 > 0 permite chegar ao yield; nos três pedidos que entregam um valor, o estado fica suspenso depois do yield com o n indicado. O pedido seguinte faz n -= 1 antes de voltar ao teste, passando por 2 > 0 e 1 > 0 até 0 > 0, que é falso e faz o quarto next(g) lançar StopIteration.

A atualização ocorre depois de retomar o yield. Suspender conserva o ponto de execução; não é voltar a chamar a função desde o início.

Gerar valores de vários intervalos

Uma lista de intervalos inteiros inclusivos, como [(2, 3), (7, 7)], pode representar o percurso 2, 3, 7 sem guardar todos os valores. Um gerador percorre cada par e suspende a cada inteiro:

def expandir_intervalos(intervalos):
    for inicio, fim in intervalos:
        for valor in range(inicio, fim + 1):
            yield valor

O contrato exige inicio <= fim em cada par. fim + 1 conserva o extremo final e um intervalo de um só valor produz esse valor uma vez. A lista exterior pode estar vazia, caso em que o gerador termina sem produzir valores. Segue a ordem recebida; se os intervalos se sobrepuserem, os valores repetem-se. O primeiro next de expandir_intervalos([(2, 3), (7, 7)]) produz 2; converter o resto em lista dá [3, 7].

Os intervalos deste exemplo incluem os dois extremos. Não confundas essa representação com as reservas semiabertas da secção anterior.

Escolher entre lista e gerador

Usa uma lista quando precisas de índices, de vários percursos ou de guardar os resultados. Um gerador permite consumir um valor de cada vez, o que pode reduzir memória. Não reduz necessariamente o trabalho total se acabares por consumir tudo.

sum(x * x for x in range(100)) consome os valores sem precisar de uma lista intermédia. Se guardares o gerador e tentares somá-lo duas vezes, a segunda soma vale zero. Criar um novo gerador inicia um novo percurso. O custo da expressão que calcula cada valor continua a existir, mesmo quando a produção é adiada.