O que é a avaliação preguiçosa em Python? – Python real

Outros tipos de dados incorporados

Os built-ins do Python zip() e enumerate() criam dois tipos de dados internos poderosos. O senhor explorará como esses tipos de dados estão vinculados à avaliação preguiçosa com o exemplo a seguir. Digamos que o senhor precise criar uma programação semanal, ou rota, que mostre quais membros da equipe levarão café pela manhã.

No entanto, a cafeteria está sempre ocupada nas manhãs de segunda-feira e ninguém quer ser responsável pelas segundas-feiras. Então, o senhor decide randomizar o rodízio toda semana. O senhor começa com uma lista contendo os nomes dos membros da equipe:

O senhor também embaralha os nomes usando random.shuffle(), que altera a lista no lugar. É hora de criar uma lista numerada para fixar no quadro de avisos toda semana:

O senhor usa enumerate() para iterar pela lista de nomes e também acessar um índice à medida que o senhor itera. Por padrão, enumerate() começa a contar a partir do zero. No entanto, o usuário usa a opção start para garantir que o primeiro número seja um.

Mas o que o enumerate() faz nos bastidores? Para explorar isso, o senhor pode chamar enumerate() e atribuir o objeto que ele retorna a um nome de variável:

O objeto criado é um enumerate que é um objeto iterador. Os iteradores são uma das principais ferramentas que permitem que o Python seja preguiçoso, pois seus valores são criados sob demanda. A chamada para enumerate() emparelha cada item em names com um número inteiro.

No entanto, ele não cria esses pares imediatamente. Os pares não são armazenados na memória. Em vez disso, eles são gerados quando o senhor precisa deles. Uma maneira de avaliar um valor de um iterador é chamar a função integrada next():

O numbered_names não contém todos os pares dentro dele. Quando ele precisa criar o próximo par de valores, ele busca o próximo nome na lista original names e o emparelha com o próximo número inteiro. O senhor pode confirmar isso alterando o terceiro nome da lista names antes de buscar o próximo valor em numbered_names:

Mesmo que o senhor tenha criado o enumerate objeto numbered_names antes de o senhor alterou o conteúdo da lista e buscou o terceiro item em names depois que o senhor o senhor fez a alteração. Esse comportamento é possível porque o Python avalia a variável enumerate de forma preguiçosa.

Olhe novamente para a lista numerada que o senhor criou anteriormente com o for que mostra que Sarah deve comprar café primeiro. Como Sarah é programadora de Python, ela perguntou se o 1 ao lado de seu nome significa que ela deve comprar café na terça-feira, já que segunda-feira deveria ser 0.

O senhor decide não ficar com raiva. Em vez disso, o senhor atualiza seu código para usar zip() para emparelhar nomes com dias da semana em vez de números. Observe que o senhor recria e embaralha a lista novamente, pois fez alterações nela:

Quando o senhor liga para zip(), o senhor cria um zip que é outro iterador. O programa não cria cópias dos dados em weekdays e names para criar os pares. Em vez disso, ele cria os pares sob demanda. Esse é outro exemplo de avaliação preguiçosa. O senhor pode explorar o zip diretamente, como o senhor fez com o objeto enumerate :

O programa não precisou criar e armazenar cópias dos dados quando o senhor chamou o enumerate() e o zip() por causa da avaliação preguiçosa. Outra consequência desse tipo de avaliação é que os dados não são fixos quando o senhor cria o enumerate ou zip objetos. Em vez disso, o programa usa os dados presentes nas estruturas de dados originais quando é necessário um valor do enumerate ou zip objetos.

Iteradores em itertools

Os iteradores são estruturas de dados preguiçosas, pois seus valores são avaliados quando são necessários e não imediatamente quando o usuário define o iterador. Há muitos outros iteradores no Python além do enumerate e zip. Todo iterável é um iterador em si ou pode ser convertido em um iterador usando iter().

No entanto, nesta seção, o senhor explorará O itertools módulo, que tem várias dessas estruturas de dados. O senhor aprenderá sobre duas dessas ferramentas agora e poderá experimentar algumas das outras depois de concluir este tutorial.

Na seção anterior, o senhor trabalhou com uma lista de membros da equipe. Agora, o senhor se une a outra equipe para participar de um questionário e deseja imprimir a lista de nomes de toda a equipe do questionário:

O iterável que o senhor usa na função for é o objeto criado pelo itertools.chain(), que encadeia as duas listas em um único iterável. No entanto, itertools.chain() não cria uma nova lista, mas um iterador, que é avaliado de forma preguiçosa. Portanto, o programa não cria cópias das cadeias de caracteres com os nomes, mas busca as cadeias de caracteres quando elas são necessárias nas listas first_name e second_name.

Aqui está outra maneira de observar a relação entre o iterador e as estruturas de dados originais:

A função sys.getrefcount() conta o número de vezes que um objeto é referenciado no programa. Observe que sys.getrefcount() sempre mostra mais uma referência ao objeto que vem da chamada ao sys.getrefcount() . Portanto, quando há apenas uma referência a um objeto no restante do programa, o senhor pode ver a referência a um objeto, sys.getrefcount() mostra duas referências.

Quando o senhor cria o chain o senhor cria outra referência para as duas listas, pois quiz_team precisa de uma referência ao local onde os dados originais estão armazenados. Portanto, sys.getrefcount() mostra uma referência extra ao first_team. Mas essa referência desaparece quando o senhor esgota o iterador:

Avaliação preguiçosa de estruturas de dados, como itertools.chain dependem dessa referência entre o iterador, como o itertools.chaine a estrutura que contém os dados, como first_team.

Outra ferramenta do itertools que destaca a diferença entre avaliação ansiosa e preguiçosa é a itertools.islice(), que é a versão de avaliação preguiçosa da fatia do Python. Crie uma lista de números e uma fatia padrão dessa lista:

Agora, o senhor pode criar uma versão de iterador da fatia usando itertools.islice():

Os argumentos do itertools.islice() incluem o iterável que o senhor deseja fatiar e os inteiros para determinar os índices de início e parada da fatia, como em uma fatia padrão. O senhor também pode incluir um argumento extra que representa o tamanho da etapa. A saída final não mostra os valores na fatia, pois eles ainda não foram gerados. Eles serão criados quando necessário.

Por fim, altere um dos valores da lista e faça um loop na fatia padrão e na fatia do iterador para comparar os resultados:

O senhor modifica o terceiro elemento da lista numbers. Essa alteração não afeta a fatia padrão, que ainda contém os números originais. Quando o senhor cria uma fatia padrão, o Python avalia essa fatia com entusiasmo e cria uma nova lista contendo o subconjunto de dados da sequência original.

No entanto, a fatia do iterador é avaliada de forma preguiçosa. Portanto, quando o senhor altera o terceiro valor na lista antes de o senhor percorra a fatia do iterador, o valor em iterator_slice também é afetado.

O senhor visitará o site itertools mais adiante neste tutorial para explorar mais alguns de seus iteradores.

Expressões do gerador e funções do gerador

As expressões que criam estruturas de dados incorporadas, como listas, tuplas ou dicionários, são avaliadas com ansiedade. Elas geram e armazenam todos os itens nessas estruturas de dados imediatamente. Um exemplo desse tipo de expressão é uma compreensão de lista:

A expressão no lado direito do operador de atribuição (=) cria uma compreensão de lista. Essa expressão é avaliada com ansiedade, e os dez valores de cara ou coroa são criados e armazenados na nova lista.

A compreensão de lista inclui um expressão condicional que retorna a string "Heads" ou "Tails" dependendo do valor da condição entre os if e else palavras-chave. As random.random() cria um float entre 0 e 1. Portanto, há uma chance de 50% de que o valor criado seja "Heads" ou "Tails".

O senhor pode substituir os colchetes por parênteses no lado direito do operador de atribuição:

A expressão entre parênteses é um expressão geradora. Embora pareça semelhante à compreensão de lista, essa expressão não é avaliada de forma ansiosa. Ela cria um objeto gerador. Um objeto gerador é um tipo de iterador que gera valores quando eles são necessários.

O objeto gerador coin_toss não armazena nenhum dos valores de string. Em vez disso, ele gerará cada valor quando for necessário. O senhor pode gerar e buscar o próximo valor usando a função integrada next():

A expressão que gera "Heads" ou "Tails" só é avaliado quando o senhor chama next(). Esse gerador gerará dez valores, pois o senhor usa range(10) no campo for do gerador. Como o senhor chamou next() duas vezes, restam oito valores a serem gerados:

O for itera oito vezes, uma vez para cada um dos itens restantes no gerador. Uma expressão de gerador é a alternativa de avaliação preguiçosa para criar uma lista ou uma tupla. Ela deve ser usada uma vez, ao contrário de suas contrapartes ávidas, como listas e tuplas.

O senhor também pode criar um objeto gerador usando um função geradora. Uma função geradora é uma definição de função que tem um yield em vez de uma declaração return . O senhor pode definir uma função geradora para criar um objeto gerador semelhante ao que usou no exemplo do lançamento de moeda acima:

O senhor cria um novo objeto gerador sempre que chama a função geradora. Ao contrário das funções padrão com returnque são avaliadas por completo, um gerador é avaliado de forma preguiçosa. Portanto, quando o primeiro valor é necessário, o código na função geradora executa o código até o primeiro yield declaração. Ele produz esse valor e faz uma pausa, aguardando a próxima vez que um valor for necessário.

Esse processo continua sendo executado até que não haja mais yield e a função geradora termine, gerando um StopIteration exceção. O protocolo de iteração no for captura essa StopIteration que é usado para sinalizar o fim do for loop.

A iteração preguiçosa em Python também permite que o senhor crie várias versões da estrutura de dados que são independentes umas das outras:

Os dois geradores, first_coin_tosses e second_coin_tossessão geradores separados criados a partir da mesma função geradora. O senhor avalia os três primeiros valores de first_coin_tosses. Isso deixa sete valores no primeiro gerador.

Em seguida, o senhor converte o segundo gerador em uma lista. Isso avalia todos os seus valores para armazená-los na lista second_as_list. Há dez valores, pois os valores que o senhor obteve do primeiro gerador não têm efeito sobre o segundo.

O senhor confirma que não há mais valores restantes no segundo gerador quando chama next() e recebe um StopIteration . No entanto, o primeiro gerador, first_coin_tosses, ainda tem valores a serem avaliados, pois é independente do segundo gerador.

Os geradores, e os iteradores em geral, são ferramentas centrais ao lidar com a avaliação preguiçosa em Python. Isso ocorre porque eles só produzem valores quando são necessários e não armazenam todos os seus valores na memória.

Avaliação de curto-circuito

Os exemplos de avaliação preguiçosa que o senhor viu até agora se concentraram em expressões que criam estruturas de dados. Entretanto, esses não são os únicos tipos de expressões que podem ser avaliadas de forma preguiçosa. Considere a expressão and e or operadores. Um equívoco comum é que esses operadores retornam True ou False. Em geral, não.

O senhor pode começar a explorar and com alguns exemplos:

Os dois primeiros exemplos têm operandos booleanos e retornam um booleano. O resultado é True somente quando ambos os operandos são True. No entanto, o terceiro exemplo não retorna um booleano. Em vez disso, ele retorna 0, que é o segundo operando em 1 and 0. E 0 and 1 também retorna 0mas, dessa vez, é o primeiro operando. O inteiro 0 é falso, o que significa que o bool(0) retorna False.

Da mesma forma, o número inteiro 1 é verdadeiro, o que significa que bool(1) retorna True. Todos os números inteiros diferentes de zero são verdadeiros. Quando o Python precisa de um valor booleano, como em um if ou com operadores como o and e orele converte o objeto em um booleano para determinar se deve ser tratado como verdadeiro ou falso.

Quando o usuário usa a função and o programa avalia o primeiro operando e verifica se ele é verdadeiro ou falso. Se o primeiro operando for falso, não há necessidade de avaliar o segundo operando, pois ambos precisam ser verdadeiros para que o resultado geral seja verdadeiro. Isso é o que ocorre na expressão 0 and 1 em que o and retorna o primeiro valor, que é falso. Portanto, a expressão inteira é falsa.

O Python não avalia o segundo operando quando o primeiro é falso. Isso é chamado de avaliação de curto-circuito e é um exemplo de avaliação preguiçosa. O Python só avalia o segundo operando se precisar dele.

Se o primeiro operando for verdadeiro, o Python avalia e retorna o segundo operando, qualquer que seja seu valor. Se o primeiro operando for verdadeiro, a veracidade do segundo operando determina a veracidade geral do and expressão.

Os dois últimos exemplos incluem operandos que são verdadeiros. O segundo operando é retornado em ambos os casos para tornar a expressão inteira verdadeira. O senhor pode confirmar que o Python não avalia o segundo operando se o primeiro for falso com os exemplos a seguir:

No primeiro exemplo, o primeiro operando é 0, e o print() nunca é chamada. No segundo exemplo, o primeiro operando é verdadeiro. Portanto, Python avalia o segundo operando, chamando a função print() . Observe que o resultado da função and é o valor retornado pela print(), que é None.

Outra demonstração impressionante de curto-circuito é quando o senhor usa uma expressão inválida como o segundo operando em um and expressão:

A chamada int("python") levanta uma ValueError pois a string "python" não pode ser convertida em um número inteiro. No entanto, nesse primeiro exemplo, o and retorna 0 sem gerar o erro. O segundo operando nunca foi avaliado!

O or funciona de forma semelhante. Entretanto, somente um operando precisa ser verdadeiro para que toda a expressão seja avaliada como verdadeira. Portanto, se o primeiro operando for verdadeiro, ele será retornado, e o segundo operando não será avaliado:

Em todos esses exemplos, o primeiro operando é retornado, pois é verdadeiro. O segundo operando é ignorado e nunca é avaliado. O senhor confirma isso com o exemplo final, que não gera um ValueError. Isso é uma avaliação de curto-circuito no or expressão. O Python é preguiçoso e não avalia expressões que não têm efeito sobre o resultado final.

No entanto, se o primeiro operando for falso, o resultado da expressão or é determinado pelo segundo operando:

A função integrada any() e all() também são avaliadas de forma preguiçosa usando a avaliação de curto-circuito. A any() retorna True se qualquer um dos elementos em um iterável for verdadeiro:

A lista que o senhor usa na primeira chamada para any() contém o número inteiro 0, o booleano Falsee uma string vazia. Todos os três objetos são falsos e any() retornam False. No segundo exemplo, o elemento final é uma cadeia de caracteres não vazia, que é verdadeira. A função retorna True.

A função para de avaliar os elementos do iterável quando encontra o primeiro valor verdadeiro. O senhor pode confirmar isso usando um truque semelhante ao que usou com a função and e or com a ajuda de uma função geradora, sobre a qual o senhor aprendeu na seção anterior:

O senhor define a função geradora lazy_values() com quatro yield declarações. A terceira declaração é inválida, pois o "python" não pode ser convertido em um número inteiro. O senhor cria um gerador quando chama essa função na chamada para any().

O programa não gera nenhum erro, e o any() retorna True. A avaliação do gerador foi interrompida quando any() encontrou a string "hello", que é o primeiro valor verdadeiro no gerador. A função any() realiza uma avaliação preguiçosa.

No entanto, se a expressão inválida não tiver nenhum valor verdadeiro antes dela, ela será avaliada e gerará um erro:

Os dois primeiros valores são falsos. Portanto, any() avalia o terceiro valor, o que gera o erro ValueError.

A função all() se comporta de forma semelhante. No entanto, all() exige que todos os elementos do iterável sejam verdadeiros. Portanto, all() entra em curto-circuito quando encontra o primeiro valor falso. O senhor atualiza a função geradora lazy_values() para verificar esse comportamento:

Esse código não gera um erro, pois o all() retorna False quando avalia a string vazia, que é o segundo elemento no gerador.

O curto-circuito, como outras formas de avaliação preguiçosa, evita a avaliação desnecessária de expressões quando essas expressões não são necessárias em tempo de execução.

Ferramentas de programação funcional

Programação funcional é um paradigma de programação no qual as funções só têm acesso aos dados inseridos como argumentos e não alteram o estado dos objetos, retornando novos objetos. Um programa escrito nesse estilo consiste em uma série dessas funções, muitas vezes com a saída de uma função usada como entrada para outra função.

Como os dados são frequentemente passados de uma função para outra, é conveniente usar a avaliação preguiçosa das estruturas de dados para evitar o armazenamento e a movimentação repetida de grandes conjuntos de dados.

Três das principais ferramentas da programação funcional são as funções incorporadas do Python map() e filter() funções e reduce()que faz parte do functools . Tecnicamente, as duas primeiras não são funções, mas construtores do módulo map e filter classes. Entretanto, o senhor as usa da mesma forma que usa as funções, especialmente no paradigma da programação funcional.

O senhor pode explorar map() e filter() com o exemplo a seguir. Crie uma lista de strings contendo nomes. Primeiro, o senhor deseja converter todos os nomes em letras maiúsculas:

O map() aplica a função str.upper() em cada item do iterável. Cada nome na lista é passado para str.upper()e o valor retornado é usado.

No entanto, map() não cria uma nova lista. Em vez disso, ele cria um map que é um iterador. Não é de surpreender que os iteradores apareçam com frequência em um tutorial sobre avaliação preguiçosa, pois eles são uma das principais ferramentas para a avaliação preguiçosa de valores!

O senhor pode avaliar cada valor, um de cada vez, usando next():

O senhor também pode converter o map em uma lista. Isso avalia os valores para que eles possam ser armazenados na lista:

Há apenas três nomes nessa lista. O senhor já avaliou e usou os dois primeiros nomes quando chamou next() duas vezes. Como os valores são avaliados quando são necessários e não armazenados na estrutura de dados, o senhor só pode usá-los uma vez.

Agora, o senhor deseja manter apenas os nomes que contenham pelo menos uma letra a. O senhor pode usar filter() para essa tarefa. Primeiro, o senhor precisará recriar o map que representa as letras maiúsculas, pois o senhor já esgotou esse gerador na sessão REPL:

Cada item no segundo argumento do filter(), que é o map objeto namesé passado para o lambda function que o senhor inclui como o primeiro argumento. Somente os valores para os quais a função lambda retorna True são mantidos. Os demais são descartados.

O senhor reutiliza a variável chamada names em cada estágio. Se preferir, o senhor pode usar identificadores de variáveis diferentes, mas se não precisar manter os resultados intermediários, é melhor usar a mesma variável. O objeto que o filter() retorna é outro iterador, um filter objeto. Portanto, seus valores ainda não foram avaliados.

O senhor pode converter o objeto filter para uma lista, como o senhor fez no exemplo anterior. Mas, nesse caso, tente fazer um loop usando um for em vez disso:

A primeira chamada de função para map() converte os nomes em letras maiúsculas. A segunda chamada, dessa vez para filter(), mantém apenas os nomes que incluem a letra a. O senhor usa letras maiúsculas A no código, pois o senhor já converteu todos os nomes para maiúsculas.

Por fim, o senhor só mantém nomes com quatro letras. O código abaixo mostra todos os map() e filter() já que o senhor precisa recriar esses iteradores todas as vezes:

O senhor pode reordenar as operações para tornar a avaliação geral mais preguiçosa. A primeira operação converte todos os nomes em maiúsculas, mas como o senhor descarta alguns desses nomes posteriormente, seria melhor evitar a conversão desses nomes. O senhor pode filtrar os nomes primeiro e convertê-los em maiúsculas na etapa final. O senhor adiciona "Andy" à lista de nomes para garantir que seu código funcione independentemente de a letra necessária ser maiúscula ou minúscula:

A primeira chamada ao filter() agora verifica se o senhor está usando letras maiúsculas ou minúsculas a está no nome. Como é mais provável que a letra a não for a primeira letra do nome, o senhor define o primeiro operando como ("a" in x) no campo or para aproveitar o curto-circuito com o or operador.

A avaliação preguiçosa obtida com o uso do map e filter iteradores significa que as estruturas de dados temporárias que contêm todos os dados não são necessárias em cada chamada de função. Isso não terá um impacto significativo nesse caso, pois a lista contém apenas seis nomes, mas pode afetar o desempenho com grandes conjuntos de dados.

Operações de leitura de arquivos

O exemplo final de expressões que são avaliadas de forma preguiçosa se concentrará na leitura de dados de um arquivo de valores separados por vírgula, geralmente chamado de arquivo CSV. Os arquivos CSV são um formato básico de arquivo de planilha eletrônica. São arquivos de texto com a extensão .csv que têm valores separados por vírgulas para indicar valores que pertencem a células diferentes na planilha. Cada linha termina com o caractere de nova linha "\n" para mostrar onde cada linha termina.

O senhor pode usar qualquer arquivo CSV que desejar para esta seção ou pode copiar os dados abaixo e salvá-los como um novo arquivo de texto com o comando .csv extensão. Nomeie o arquivo CSV superhero_pets.csv e coloque-o na pasta do seu projeto:

O senhor explorará duas maneiras de ler dados desse arquivo CSV. Na primeira versão, o senhor abrirá o arquivo e usará o comando .readlines() para objetos de arquivo:

O senhor importa pprint para permitir a impressão bonita de grandes estruturas de dados. Depois de abrir o arquivo CSV usando o with gerenciador de contextoespecificando a codificação do arquivo, o usuário chama o comando .readlines() para o arquivo aberto. Esse método retorna uma lista que contém todos os dados da planilha. Cada item da lista é uma cadeia de caracteres que contém todos os elementos em uma linha.

Essa avaliação é ávida, pois o .readlines() extrai todo o conteúdo da planilha e o armazena em uma lista. Essa planilha não contém muitos dados. No entanto, esse caminho pode levar a uma pressão significativa sobre os recursos de memória se o senhor estiver lendo grandes quantidades de dados.

Em vez disso, o senhor pode usar a função csv do Python, que faz parte da biblioteca padrão. Para simplificar esse código no REPL, o senhor pode abrir o arquivo sem usar um with gerenciador de contexto. No entanto, o senhor deve se lembrar de fechar o arquivo ao fazer isso. Em geral, o senhor deve usar o with para abrir arquivos sempre que possível:

O senhor adiciona o argumento nomeado newline="" ao abrir o arquivo a ser usado com o csv para garantir que todas as novas linhas dentro dos campos sejam tratadas corretamente. O objeto retornado por csv.reader() não é uma lista, mas um iterador. O senhor já se deparou com iteradores várias vezes neste artigo para saber o que esperar.

O conteúdo da planilha não é armazenado em uma estrutura de dados no programa Python. Em vez disso, o Python buscará preguiçosamente cada linha quando for necessário, obtendo os dados diretamente do arquivo, que ainda está aberto:

A primeira chamada para next() aciona a avaliação do primeiro item da tabela data iterador. Essa é a primeira linha da planilha, que é a linha do cabeçalho. O senhor chama next() mais duas vezes para obter as duas primeiras linhas de dados.

O senhor pode usar um for para iterar pelo restante do iterador e avaliar os itens restantes:

O senhor avaliou o cabeçalho e as duas primeiras linhas no código anterior. Portanto, o for só tem as três últimas linhas para iterar. E é uma boa prática fechar o arquivo Como o senhor não está usando um with declaração.

O reader() na função csv permite que o senhor avalie as linhas da planilha de forma preguiçosa, buscando cada linha somente quando for necessário. Entretanto, chamar o .readlines() em um arquivo aberto avalia as linhas de forma ansiosa, buscando todas elas imediatamente.