Iteradores em Python

Um iterador é uma ferramenta valiosa para o Python. É um objeto usado para iterar todos os elementos de uma coleção. O iterador dá acesso aos elementos de um recipiente, mas não faz a iteração por conta própria. Funciona como um cursor de banco de dados e é usado para ler a lista de registros um por um. Por exemplo, um 'para'Loop que itera os valores de um contêiner funciona como um iterador. Python tem muitos iteradores embutidos para objetos iteráveis, como listas, tuplas, dicionários, etc. Sem esses iteradores, 'itetools'As funções podem ser usadas para devolver outros iteradores em Python. Este artigo mostra como usar o loop como iterador, iterador personalizado, iterador infinito e controlador infinito no Python 3. Alguns usos do 'itetools'As funções também são explicadas na última parte deste tutorial.

Métodos do iterador

Cada objeto iterador contém os dois métodos a seguir.

• _ _iter_ _ ()

Este método é usado para inicializar o objeto iterável. O objeto retornado tem o método '_ _próximo_ _()'Em Python 3.

• _ _próximo_ _()

Este método retorna o próximo valor do objeto iterável. A relação entre o iterador e o objeto iterável é mostrado no diagrama a seguir.

Iterando com loops

Foi mencionado anteriormente que 'para'Loop chama o'próximo()'Método implicitamente quando itera qualquer objeto iterável. Quando um loop é usado para iterar um objeto iterável, o 'para'Loop chama o'próximo()'Método implicitamente e o'enquanto'Loop chama o'próximo()' ou '__próximo__()'Método explicitamente para ler o próximo valor do objeto iterável. Ambos os tipos de loop continuam chamando esse método até o 'Stopiberation'O sinal é gerado.

Exemplo 1: iterando objetos iteráveis ​​com 'para' loop

O script a seguir mostra o uso de 'para'Loops para iterar cinco objetos iteráveis ​​diferentes. O primeiro 'para'O loop é usado para iterar o valor da string e imprimir cada caractere da string em cada iteração. O segundo 'para'O loop é usado para iterar o conteúdo de um arquivo de texto existente e imprimir cada linha do arquivo em cada iteração. O terceiro 'para'O loop é usado para iterar os valores de uma tupla. O quarto 'para'O loop é usado para iterar os valores contidos em uma lista. O quinto 'para'O loop é usado para iterar os valores contidos em um dicionário.

# Iterando uma string usando o loop
print ("iteração de string usando para loop")
str = "python"
Para Val em Str:
Imprimir (Val)
# Iterando um arquivo existente usando o loop
print ("\ n \ n lerendo uma linha de arquivo por linha usando o loop")
para linha em aberto ("teste.TXT"):
Imprimir (linha, end = "")
# # Iterando uma tupla usando o loop
Imprimir ("\ n \ ntuple iteração usando o loop")
tup = ("livro", "papel", "lápis", "caneta")
Para Val em Tup:
Imprimir (Val)
# Iterando uma lista usando o loop
Imprima ("\ n \ nlist iteração usando o loop")
ListData = ["Designer", "Analista", "Programador", "Administrador"]
Para Val em ListData:
Imprimir (Val)
# Iterando um dicionário usando o loop
Imprimir ("\ n \ ndictionary iteração usando o loop")
dictval = 'meher': 95, 'sakib': 97, 'akhi': 70, 'fiaz': 78
para índice em dictval:
print (" %s alcançado %d marcas" %(índice, dictVal [índice])))

Saída

A saída a seguir mostra que os caracteres do valor da string; as linhas do teste.TXT arquivo; e os itens das tuplas, lista e dicionário são impressos após a execução do script.

Exemplo 2: listas de iteração com 'while' loop

O script a seguir mostra o uso de A 'enquanto'Loop para iterar uma lista de dados. Aqui o 'iter ()'O método é usado para inicializar o objeto iterável e o'próximo()'O método é usado para ler o próximo valor do objeto iterável. Stopiberation o sinal é usado para terminar do infinito 'enquanto' loop quando nenhum item da lista deixou para leitura.

# Defina uma lista
ListData = ['Google.com ',' Bing.com ',' Yahoo.com ',' Baidu.com ',' Duckduckgo.com ']
# Inicialize o objeto iterável
init_iter_object = iter (listData)
Print ("Dados da lista de iteração usando o loop: \ n")
# Declare e infinito enquanto loop
enquanto é verdade:
tentar:
# o método next () é usado para o próximo valor iterado
valor = a seguir (init_iter_object)
Imprimir (valor)
Exceto parada:
# Termine do loop após a iteração de todos os valores
quebrar

Saída

A saída a seguir mostra que cada valor da lista foi impresso em cada linha usando o 'próximo()'Método depois de executar o script.

Exemplo 3: iterando uma tupla com '__next __ ()' 'e' while loop

No script a seguir, ambos 'próximo()' e '__próximo__()'Os métodos são usados ​​para iterar os valores de uma tupla. O 'iter ()'O método é usado para criar o objeto iterável, chamado'init_iter.' Aqui o 'próximo()'O método é chamado duas vezes para imprimir os dois primeiros valores da tupla. Em seguida, um infinito 'enquanto'Loop é usado para iterar os valores restantes da tupla e do'Stopiberation'O sinal é usado para terminar a partir do loop, como no exemplo anterior.

# Defina uma tupla
animal_tuple = ('pássaro', 'leão', 'macaco', 'cobra', 'elefante')
print ("Os valores da tupla são: \ n")
# Inicialize um objeto de iterador usando o iter ()
init_iter = iter (animal_tuple)
# itera e imprimir valor usando o método seguinte ()
Imprimir (Next (init_iter))
Imprimir (Next (init_iter))
# Defina um infinito enquanto o loop
enquanto é verdade:
tentar:
# itera e imprimir valor usando o método __Next __ ()
print (init_iter.__próximo__())
Exceto parada:
# Termine do loop após a iteração de todos os valores
quebrar

Saída

A saída a seguir mostra que, depois de executar o script, os dois primeiros valores ''Pássaro' e 'Leão,'são impressos com o'próximo()'método, enquanto os outros três valores'Macaco,"Cobra,' e 'Elefante,'são impressos com o'__próximo__()'Método.

Iterando com um iterador personalizado

Esta seção mostra como diferentes tipos de iteradores personalizados podem ser implementados criando classes. Ambos '__iter __ ()' e a '__próximo__()'Os métodos serão implementados em uma classe e o'enquanto'Loop será usado para iterar os valores do objeto iterável. A próxima parte deste artigo também mostrará como criar um iterador personalizado infinito e controlar a iteração.

Exemplo 4: Uso de um iterador personalizado simples

O script a seguir permite calcular o valor de xⁿ Usando um iterador personalizado sem usar qualquer função interna do Python. A classe chamada 'x_to_the_power_n'é declarado no script. O '__iniciar__()'O método da classe inicializará os valores de x e n que será usado no momento da criação de objetos. O '__iter __ ()'O método inicializará a variável de classe, que armazenará o'resultado'variável do cálculo em cada iteração. Os valores de x e n será tomado como entrada do usuário. Um objeto da classe 'números'é criado com x e n. Em seguida, um objeto iterável chamado 'iter_obj'é criado para chamar o'__próximo__()'Método para N-1 tempos usando o 'enquanto'loop para calcular o valor de xⁿ. Em cada iteração, o valor de x será multiplicado pelo valor anterior do 'resultado' variável. Depois de encerrar o 'enquanto'Loop, o'__próximo__()'O método será chamado novamente para imprimir o valor de xⁿ.

"Crie uma classe para calcular o
x para o poder n usando o iterador
"
classe x_to_the_power_n:
# Inicialize o valor de x e n
def __init __ (self, x = 0, n = 0):
auto.x = x
auto.n = n
# Inicialize o iterável
def __iter __ (self):
auto.resultado = 1
retornar a si mesmo
# Calcule o valor em cada iteração
def __next __ (self):
se eu.n> = 0:
auto.resultado *= self.x
auto.n -= 1
retornar a si mesmo.resultado
# Pegue os valores de x e n
x = int (entrada ("Digite o valor de x:")))
n = int (entrada ("Digite o valor de n:")))
# Crie um objeto da classe
números = x_to_the_power_n (x, n)
# Crie um iterável
iter_obj = iter (números)
tentar:
i = 0
enquanto eu < n-1):
# Recuperar o próximo valor usando o método Next ()
Próximo (iter_obj)
i+= 1
print ("\ n %d para a potência %d é %d" %(x, n, iter_obj.__próximo__()))
Exceto parada:
# Termine do script se não houver valor
Imprimir (Next (Iter_Obj))

Saída

A saída a seguir mostra que 2 é considerado o valor de x e 4 é considerado o valor de n. Então, o script calculou o valor de 2⁴ ser 16.

Exemplo 5: Uso de um Iterador Custom Infinito

O script a seguir imprimirá continuamente os números divisíveis por 5 com um atraso de um segundo até que o usuário pressione Ctrl + c Para gerar o 'Teclado interruptora'sinal. O infinito 'enquanto'O loop é usado aqui para criar um iterador personalizado infinito. O 'tempo'O módulo é importado no início do script para usar o'dormir()'Método para adiar cada saída para um segundo. O número 5 é inicializado para o 'num'Variável como o primeiro número divisível no script, e o próximo número é gerado adicionando 5 com o valor anterior do'num' variável.

# Módulo de tempo de importação
tempo de importação
"
Crie uma classe para gerar os números
que são divisíveis por 5 continuamente
"
Classe number_divisible_by_five:
# Inicialize o valor de num
def __iter __ (self):
auto.num = 5
retornar a si mesmo
# Calcule o próximo número divisível por 5
def __next __ (self):
next_num = self.num
tempo.sono (1)
auto.NUM += 5
retornar next_num
# Crie um objeto da classe
Objeto = number_divisible_by_five ()
# Crie objeto iterável
iterObject = iter (objeto)
# Definir loop infinito
enquanto é verdade:
tentar:
# Vá para a próxima iteração
IMPRESSÃO (IREROBJECT.__próximo__())
Exceto keyboardInterrupt:
print ("Ctrl+C é pressionado.")
# Termine do loop quando Ctrl+C é pressionado
quebrar

Saída

A saída a seguir mostra que o número começou a imprimir de 5 e continuou continuamente os próximos números um após o outro com uma duração de um segundo. Quando o usuário pressionou Ctrl + c Depois de imprimir o número 60, a mensagem 'Ctrl+C é pressionado.'foi impresso antes de encerrar o script.

Exemplo 6: Controlar um Iterador Infinito personalizado

O script a seguir mostra como interromper o iterador infinito personalizado depois de concluir um número especificado de iterações. O '__iter __ ()'O método da classe inicializará os valores do'n' e 'resultadoVariáveis ​​de classe. O script calculará os quadrados dos números, começando de 1, que são armazenados na variável n, e imprima o valor quadrado de n até o valor de n é melhor que 5. Um infinito enquanto o loop é declarado aqui para ligar para o '__próximo__()'Método para imprimir o valor quadrado de n. Quando o valor de n alcance 6, o 'Stopiberation'O sinal gerará para encerrar o loop.

# Módulo de tempo de importação
tempo de importação
"
Crie uma classe para calcular
O quadrado do número começa de 1 até
O valor do número é menor que 6
"
Classe calcular_power:
# Inicialize o valor de num
def __iter __ (self):
auto.n = 1
auto.resultado = 0
retornar a si mesmo
# Calcule o próximo número divisível por 5
def __next __ (self):
# Verifique se o valor de n é menor ou igual a 5 ou não
se eu.n <= 5:
auto.resultado = self.n ** 2
tempo.sono (0.5)
auto.n += 1
retornar a si mesmo.resultado
outro:
levantar a parada
# Crie um objeto da classe
Objeto = calcular_power ()
# Crie objeto iterável
iterObject = iter (objeto)
# Definir loop infinito
enquanto é verdade:
tentar:
# Vá para a próxima iteração e imprima o valor quadrado
print ("o quadrado de %d é %d" %(iterObject.n, iterObject.__próximo__()))
Exceto parada:
impressão ("\ terminado do loop.")
# Termine do loop
quebrar

Saída

A saída a seguir mostra que o Iterador Custom Infinito foi encerrado quando o valor de n se tornou maior que 5. O script calculou e imprimiu os valores quadrados dos valores numéricos de 1 a 5.

Iterando com itterols

Python tem um módulo embutido chamado 'itetools'Isso pode ser usado para criar um iterador para iterando dados usando um loop. A próxima seção deste artigo mostra como usar três funções neste módulo.

itetools.contar()

O 'ITERTOOLS.cont'A função pode ser usada com o'mapa()'Método para gerar dados seqüenciais e com o'fecho eclair()'Método para adicionar sequências usando o parâmetro de contagem deste método. A sintaxe desta função é dada abaixo.

Sintaxe

itetools.contagem (start = 0, etapa = 1)

Aqui, o primeiro parâmetro, 'começar,'é usado para definir o valor inicial da sequência e 0 é o valor padrão deste parâmetro. O segundo parâmetro, 'etapa,'é usado para definir a diferença entre os números consecutivos e 1 é o valor padrão deste parâmetro.

Exemplo 7: Uso de contagem () Função de ITERTOOLS

O script a seguir calculará a soma de 0 para n números, onde o valor de n será retirado do usuário. O 'contar()'A função é importada de'itetools'No início do script. O 'my_iterator'Objeto é inicializado com o'contar()'função, com um'começar'Valor de 0 e A'etapa'valor de 1. Em seguida, o 'SUM_RESULT'A variável é inicializada pelo primeiro valor do objeto iterável. O valor inicial é inicializado para a variável eu e o número inicial é armazenado como o personagem na variável, números que serão usados ​​para combinar outros números em cada iteração. Os valores dos números seqüenciais serão adicionados em cada iteração quando 'próximo()'O método é chamado. Quando o valor de eu torna -se maior que n, O script terá rescisão exibindo o resultado da soma.

"O script a seguir calculará
a soma de 0 para o número que será tomado como entrada.
"
# Counto de importação
da contagem de importação de itertools
# Cria um objeto iterável de Count ()
my_iterator = count (start = 0, passo = 1)
# Leia o primeiro valor do iterador
sum_result = a seguir (my_iterator)
# Pegue uma entrada numérica para rescindir o infinito enquanto o loop
n = int (entrada ("Digite o valor limite:")))
# Inicialize o valor de i e números
i = sum_result
números = f 'i'
# Declare loop infinito
enquanto é verdade:
# Adicione o número em cada iteração
sum_result += eu
i = próximo (my_iterator)
# Encerrar o loop se o valor de i for mais do que n
se (i> n):
quebrar
# Adicione o valor do número como uma string com símbolo '+'
números += " +" +f 'i'
# Imprima o valor final
print (" %s = %d" %(números, sum_result))

Saída

A saída a seguir mostra que o número 10 é tomado como a entrada usada para encerrar o loop após a execução do script. Nesta saída, o script calculou a soma de 0 a 10 e imprimiu a saída, 0+1+2+3+4+5+6+7+8+9+10 = 55.

Itetools.ciclo()

Esta função contém apenas um argumento, que pode ser qualquer objeto. O objetivo desta função é repetir os valores do objeto após concluir a iteração de todos os valores. Aqui, cordas, tuplas, listas, etc. pode ser usado como objeto. O objeto iterável retorna desta função é usado para iterar cada valor do objeto que será usado como argumento usando o 'próximo()'Método. O número de vezes que os valores do objeto iterável irão iterar serão baseados no número de iterações do loop. A sintaxe desta função é dada abaixo.

Sintaxe

itetools.ciclo (objeto)

Exemplo 8: Uso da Função Cycle () de ITERTOOLS

O 'aleatório' e 'itetools'Os módulos são importados no início do script para gerar um número aleatório e usar o'ciclo()'Função do'itetools'Módulo para repetir os dados. Uma lista de três números aleatórios é usada como argumento do 'ciclo()'função. O objeto iterável chamado 'num_list'é inicializado pelo valor de retorno desta função. O 'contar'A variável é inicializada para 0, e quando o valor dessa variável se torna 6, o 'enquanto'Loop terá rescisão. Então o 'enquanto'O loop iterará seis vezes, e cada valor da lista repetirá apenas uma vez.

# Importar módulo aleatório
importar aleatório
# Importar módulo ITERTOOLS
importar itterols
# Gere um objeto iterável com base na lista de três números aleatórios
NUM_LIST = ITERTOOLS.ciclo ([aleatório.Randint (1,5), aleatório.Randint (10,50), aleatório.Randint
(100.500)])
# Inicialize o contador
contagem = 0
# Itera o loop por 6 vezes
enquanto (conte != 6):
print ('O número aleatório atual é:' + f 'next (num_list)')
contagem+= 1

Saída

A saída a seguir mostra que três números aleatórios, 3, 17, e 185, foram gerados como itens de lista. O loop é iterado seis vezes e esses três valores são repetidos para as próximas iterações.

Itetools.repita()

A função 'repetição ()' funciona como um iterador infinito e pode levar dois argumentos. Quando o segundo argumento é omitido, a função 'repetição ()' funciona como um iterador infinito e repete o valor um número infinito de vezes. Esta função não ocupa memória para cada repetição. Ele apenas cria a variável uma vez na memória e repete a mesma variável um número infinito de vezes em que apenas um argumento é definido para esta função. A sintaxe desta função é dada abaixo.

Sintaxe

itetools.Repita (valor, limite)

O primeiro argumento é usado para aceitar o valor que repetirá. O segundo argumento é opcional e é usado para definir o limite de repetições.

Exemplo 9: Uso de repetição () Função do módulo ITERTOOLS

O 'itetools'O módulo é importado no início do script para usar o'repita()'função. Um valor de string será retirado do usuário para repetir e um valor numérico será retirado do usuário para definir o limite de repetição. O valor de retorno do 'repita()'A função será então convertida em uma lista com o'lista()'método e armazenado no'ListData' variável. Os valores do 'ListData'será impresso com o'para' laço.

# Importar módulo ITERTOOLS
importar itterols
# Pegue o valor de entrada que repetirá
string = input ("Digite uma string:")
# Pegue o valor do número para repetir
repetir = int (entrada ("Digite o número a repetir:")))
# usando repetir () para adicionar repetidamente a string a uma lista
ListData = List (ITERTOOLS.Repita (string, repita))
# Inicie i
i = 1
print ("Os valores da lista são: \ n")
# Itera a lista usando o loop
Para Val em ListData:
print ("Lista item %d = %s" %(i, val))
i += 1

Saída

A saída a seguir mostra que 'Pitão'é considerado o valor da string e 3 é considerado como o número usado para repetir o valor da string após a execução do script. A saída mostra que a string 'Pitão'é repetido três vezes.

Conclusão

O conceito de iterador e os usos de diferentes tipos de iteradores em Python são tentados para explicar com os exemplos muito simples deste artigo. Os usuários do Python podem usar um iterador embutido ou podem criar seu iterador personalizado com base no requisito. Este artigo ajudará os usuários do Python a saber sobre os métodos usados ​​no iterador e como esses métodos funcionam com qualquer loop para ler qualquer objeto iterável. Alguns usos de itetools O módulo de Python também é explicado neste artigo para saber mais detalhes do iterador em Python.