Analise o código Python a seguir.class enigma:     def __ite...

Resposta Correta: C - 16

Para resolver esta questão, você precisa entender a implementação de iteradores em Python. Um iterador é um objeto que permite ao programador percorrer todos os elementos de um container (como uma lista ou um dicionário), independentemente da estrutura de dados específica do container. A classe enigma definida no código está implementando um iterador customizado através da definição dos métodos especiais __iter__() e __next__().

O método __iter__() simplesmente inicializa o valor de self.x em 128 e retorna o próprio objeto como um iterador. O método __next__(), que é chamado a cada iteração, define uma função lambda z que recebe um valor a e retorna a - int(a/2), que é basicamente o valor de a dividido por dois, sem o resto. Em seguida, atualiza self.x com o resultado da função lambda e retorna o valor antigo de self.x.

Quando o loop for é executado, ele chama o método __next__() cinco vezes, uma para cada iteração. Aqui estão os resultados a cada iteração:

• 1ª Iteração: self.x = 128, y = 128, após a função lambda self.x = 64
• 2ª Iteração: self.x = 64, y = 64, após a função lambda self.x = 32
• 3ª Iteração: self.x = 32, y = 32, após a função lambda self.x = 16
• 4ª Iteração: self.x = 16, y = 16, após a função lambda self.x = 8
• 5ª Iteração: self.x = 8, y = 8, após a função lambda self.x = 4

Portanto, o quarto número exibido pelo print durante a execução do código é 16, o que torna a alternativa C a correta.

O código define uma classe que implementa os métodos e necessários para que um objeto da classe possa ser usado como iterador. Quando um objeto da classe é criado e seu método é chamado, ele inicializa a variável com o valor 128 e retorna .

O método é responsável por retornar o próximo elemento da sequência. Ele armazena o valor atual de na variável , calcula o próximo valor de aplicando uma função lambda que subtrai a metade do valor de do próprio valor, e então retorna o valor de .

No loop , um objeto iterador é criado a partir de um objeto e é chamado o método do iterador para imprimir os próximos valores da sequência. Como o loop é executado 5 vezes, serão impressos os primeiros 5 valores da sequência.

Os primeiros quatro valores da sequência serão 128, 64, 32 e 16, respectivamente. Portanto, o quarto número exibido na execução do código será 16.

Como resolver questões de Python sem identação?

Essa questão precisa de formatação. Para ajudar na compreensão:

class enigma:

  def __iter__(self):

    self.x = 128

    return self

  def __next__(self):

    y = self.x

    z = lambda a : a - int(a/2)

    self.x = z(self.x)

    return y

coisa = enigma()

xpto = iter(coisa)

for k in range(5):

  print(next(xpto))

Os números exibidos são:

128

64

32

16

8

class enigma:

 def __iter__(self):

   self.x = 128

   return self

 def __next__(self):

   y = self.x

   z = lambda a : a - int(a/2)

   self.x = z(self.x)

   return y

coisa = enigma()

xpto = iter(coisa)

for k in range(5):

 print(next(xpto))

1ª iteração

self.x = 128 / 2 = 64

retorna y=128

2ª iteração

self.x = 64 / 2 = 32

retorna y=64

3ª iteração

self.x = 32 / 2 = 16

retorna y=32

4ª iteração

self.x = 16 / 2 = 8

retorna y=16

5ª iteração

self.x = 8 / 2 = 4

retorna y=8

O quarto item que será impresso é 16.

A prova com indentação está nesse link:

https://arquivos.qconcursos.com/prova/arquivo_prova/92309/fgv-2023-receita-federal-auditor-fiscal-manha-prova.pdf?_ga=2.241499850.977960604.1700742582-2048531100.1700742582

Questão 78

Resolvendo a questão:

para k=1

y <- x = 128

z = 128/2 = 64

x <- z = 64

return y

apresenta na tela o valor de Y (128)

para k=2

y <- x = 64

z = 64/2 = 32

x <- z = 32

return y

apresenta na tela o valor de Y (64)

para k=3

y <- x = 32

z = 32/2 = 16

x <- z = 16

return y

apresenta na tela o valor de Y (32)

para k=4

y <- x = 16

z = 16/2 = 8

x <- z = 8

return y

apresenta na tela o valor de Y (16)