sirve - ¿Por qué iterator se considera estilo funcional en la documentación de Python?

python pdf

Question

Estoy tratando de entender el iterador. Noto que la documentación de Python considera que iterator es una construcción de estilo funcional. Realmente no lo entiendo

¿No es verdad que el iterador tiene un estado dentro de él? Entonces cuando lo llamas it.__next__() , cambias el estado del iterador. Hasta donde sé, el estado de mutación de un objeto no se considera funcional, ya que la programación funcional enfatiza la inmutabilidad y la capacidad de composición del objeto / cierre.

En realidad, surge el problema porque quiero escribir un procedimiento / función Scheme que toma tokens y devuelve un iterador.

(define tokens->iterator
(lambda ls
(lambda ()
(if (null? ls)
''*eoi*
(let ((tok (car ls)))
(set! ls (cdr ls))
tok)))))

¡Note que tengo que usar set! para mutar ls , así es como surge esta pregunta.

Para usarlo,

(define it (tokens->iterator 1 ''+ 2))

Para probarlo,

scheme@(guile-user)> (it)
$2 = 1
scheme@(guile-user)> (it)
$3 = +
scheme@(guile-user)> (it)
$4 = 2
scheme@(guile-user)> (it)
$5 = *eoi*
scheme@(guile-user)> (it)
$6 = *eoi*

Solo por diversión, también traduzco esto a Python:

def tokens_to_iterator(*tup):
ls = list(tup)
def iterator():
if not ls:
return "*eoi*"
else:
tok = ls.pop(0)
return tok
return iterator

De manera similar, el método pop () elimina y devuelve el primer elemento al mutar la lista.

Para usarlo,

it = tokens_to_iterator(1, "+", 2)

Para probarlo,

>>> it()
1
>>> it()
''+''
>>> it()
2
>>> it()
''*eoi*''
>>> it()
''*eoi*''

¿Alguien puede aclarar sobre esto? Por cierto, estoy usando Python 3 y Guile Scheme en caso de que alguien esté interesado en probar los ejemplos.

Answer 1

El estilo funcional es trabajar con listas de datos como un todo, en lugar de una colección de valores que puede cambiar por capricho. Por ejemplo, si tiene una lista de números y desea cambiar el tercer elemento, el enfoque no funcional es cambiarlo directamente:

>>> lst = ["a", "b", "c", "d", "e"]
>>> lst[3] = "Z"
>>> lst
["a", "b", "c", "Z", "e"]

El enfoque funcional es escribir una función que tome la secuencia original y devuelva una nueva lista con el cambio realizado, sin modificar el original.

>>> lst = ["a", "b", "c", "d", "e"]
>>> new_lst = [x if i != 3 else "Z" for (i, x) in enumerate(lst)]
>>> lst
["a", "b", "c", "d", "e"]
>>> new_lst
["a", "b", "c", "Z", "e"]

Ninguno de sus iteradores es puramente funcional, ya que mantienen el estado mutable, aunque se trata como un recuadro negro, puede usarlos funcionalmente porque el usuario del iterador no puede afectar ese estado directamente.

Un iterador puramente funcional sería una función que toma como entrada la lista y el estado actual, y devuelve un valor y un nuevo estado para pasar a la siguiente llamada de la función.

>>> state = 0
>>> def it(lst, state):
... if state is None:
... return None
... return lst[state], state + 1
...
>>> lst = ["a", "b", "c", "d", "e"]
>>> value, new_state = it(lst, state)
>>> value
''a''
>>> state, new_state
(0, 1)
>>> it(lst, new_state)
(''b'', 2)
>>> state, new_state
(0, 1)

Answer 2

Tienes un excelente punto. Los iteradores ciertamente no son "puramente funcionales", el término que a menudo se usa para describir modismos que no usan ninguna mutación. El término más amplio "funcional", sin embargo, está definido de manera más vaga para indicar programas que usan relativamente poca mutación, que hacen uso de funciones de orden superior y de primera clase, y quizás más ampliamente de todo, "usan extrañas abstracciones que no parecerse a C. "

Creo, para ser sincero, que no llamaría iteradores funcionales. Es decir: estoy de acuerdo contigo.