Scope dinámico

1 files changed, 91 insertions, 75 deletions

diff --git a/src/04_funciones.md b/src/04_funciones.md
index c99ef04..669e796 100644
--- a/src/04_funciones.md
+++ b/src/04_funciones.md
@@ -195,70 +195,6 @@ pero sí al revés. Los casos son los siguientes:
 [^generator-expression]: <https://www.python.org/dev/peps/pep-0289/>
 
 
-### Global
-
-Hemos hablado de qué sentencias crean nuevos contextos, pero no hemos hablado
-de qué pasa si esos nuevos contextos crean referencias cuyo nombre es idéntico
-al de las referencias globales.
-
-Partiendo de lo que se acaba de explicar, y antes de adentrarnos en ejemplos,
-si se crea una función (o cualquiera de las otras estructuras) python creará un
-contexto para ella. Una vez creado, al crear una variable en este nuevo
-contexto, python añadirá una nueva entrada en su tabla hija con el nombre de la
-variable. Al intentar consultarla, python encontrará que en su tabla hija
-existe la variable y tomará el valor con el que la declaramos. Cuando la
-función termine, la tabla de contexto asociada a la función será eliminada.
-Esto siempre es así, independientemente del nombre de referencia que hayamos
-seleccionado. Por tanto, si el nombre ya existía en alguno de los contextos
-padre, lo ocultaremos, haciendo que dentro de esta función se encuentre el
-nombre recién declarado y no se llegue a buscar más allá. Cuando la función
-termine, como el contexto asociado a ésta no está en la zona de búsqueda de la
-función madre, en la función madre el valor seguirá siendo el que era.
-
-Ilustrándolo en un ejemplo:
-
-``` python
->>> a = 1
->>> def f():
-...     a = 2
-...     print(a)
-...
->>> a
-1
->>> f()
-2
-```
-
-Aunque el nombre de la referencia declarada en el interior sea el mismo que el
-de una referencia externa su declaración no afecta, lógicamente, al exterior
-ya que ocurre en un contexto independiente.
-
-Para afectar a la referencia externa, python dispone de la sentencia `global`.
-La sentencia `global` afecta al bloque de código actual, indicando que los
-identificadores listados deben interpretarse como globales. De esta manera, si
-se reasigna una referencia dentro de la función, no será el contexto propio el
-que se altere, sino el contexto padre que la albergue.
-
-``` python
->>> a = 1
->>> def f():
-...     global a
-...     a = 2
-...     print(a)
-...
->>> f()
-2
->>> a
-2
-```
-
-> NOTA: Te recomiendo, de todas formas, que no edites valores globales desde
-> el cuerpo de funciones. Es más elegante y comprensible si los efectos de las
-> funciones sólo se aprecian en los argumentos de entrada y salida.
-
-Para más detalles sobre limitaciones y excepciones, puedes buscar en la ayuda
-ejecutando `help("global")`.
-
 ### Scope léxico, Closures
 
 Hemos dicho que las funciones pueden declararse dentro de funciones, pero no
@@ -332,6 +268,87 @@ A nivel práctico, las *closures* son útiles para muchas labores que iremos
 desgranando de forma accidental. Si tienes claro el concepto te darás cuenta
 dónde aparecen en los futuros ejemplos.
 
+### Scope dinámico: `global` y `nonlocal`
+
+Hemos hablado de qué sentencias crean nuevos contextos, pero no hemos hablado
+de qué pasa si esos nuevos contextos crean referencias cuyo nombre es idéntico
+al de las referencias que aparecen en contextos superiores.
+
+Partiendo de lo que se acaba de explicar, y antes de adentrarnos en ejemplos,
+si se crea una función (o cualquiera de las otras estructuras) python creará un
+contexto para ella. Una vez creado, al crear una variable en este nuevo
+contexto, python añadirá una nueva entrada en su tabla hija con el nombre de la
+variable. Al intentar consultarla, python encontrará que en su tabla hija
+existe la variable y tomará el valor con el que la declaramos. Cuando la
+función termine, la tabla de contexto asociada a la función será eliminada.
+Esto siempre es así, independientemente del nombre de referencia que hayamos
+seleccionado. Por tanto, si el nombre ya existía en alguno de los contextos
+padre, lo ocultaremos, haciendo que dentro de esta función se encuentre el
+nombre recién declarado y no se llegue a buscar más allá. Cuando la función
+termine, como el contexto asociado a ésta no está en la zona de búsqueda de la
+función madre, en la función madre el valor seguirá siendo el que era.
+
+Ilustrándolo en un ejemplo:
+
+``` python
+>>> a = 1
+>>> def f():
+...     a = 2
+...     print(a)
+...
+>>> a
+1
+>>> f()
+2
+```
+
+Aunque el nombre de la referencia declarada en el interior sea el mismo que el
+de una referencia externa su declaración no afecta, lógicamente, al exterior
+ya que ocurre en un contexto independiente.
+
+Para afectar a la referencia global, python dispone de la sentencia `global`.
+La sentencia `global` afecta al bloque de código actual, indicando que los
+identificadores listados deben interpretarse como globales. De esta manera, si
+se reasigna una referencia dentro de la función, no será el contexto propio el
+que se altere, sino el contexto global, el padre de todos los contextos.
+
+``` python
+>>> a = 1
+>>> def f():
+...     global a
+...     a = 2
+...     print(a)
+...
+>>> f()
+2
+>>> a
+2
+```
+
+> NOTA: Te recomiendo, de todas formas, que no edites valores globales desde
+> el cuerpo de funciones. Es más elegante y comprensible si los efectos de las
+> funciones sólo se aprecian en los argumentos de entrada y salida.
+
+Para más detalles sobre limitaciones y excepciones, puedes buscar en la ayuda
+ejecutando `help("global")`.
+
+El caso de `nonlocal` es similar, sin embargo, está diseñado para trabajar en
+contextos anidados.  Es decir, en lugar de saltar a acceder a una variable
+global, `nonlocal` la busca en cualquier contexto que no sea el actual.
+`nonlocal` comienza a buscar las referencias en el contexto padre y va saltando
+hacia arriba en la jerarquía en busca de la referencia. Para saber más:
+`help("nonlocal")`.
+
+La diferencia principal entre ambas es que `global` puede crear nuevas
+referencias, ya que se sabe a qué contexto debe afectar: al global. Sin
+embargo, `nonlocal` necesita que la referencia a la que se pretende acceder
+esté creada, ya que no es posible saber a qué contexto se pretende acceder.
+
+Las sentencias `global` y `nonlocal` son tramposas, ya que son capaces de
+alterar el comportamiento del *scope léxico* y convertirlo en *scope dinámico*.
+El *scope dinámico* es el caso opuesto al léxico, en el que las funciones
+acceden a valores definidos en el contexto donde se ejecutan, no donde se
+crean.
 
 ## Argumentos de entrada y llamadas
 
@@ -610,26 +627,25 @@ sencilla, y todos los conceptos importantes relacionados con ellas. Un
 conocimiento que es útil en python, pero que puede ser extendido a casi
 cualquier lenguaje.
 
-Partiendo del *scope*, has aprendido la diferencia entre lo *local* y lo
-*global*. Después, has comprendido que las funciones en python son sólo un
-valor más, como puede ser un `int`, y que pueden declararse en cualquier lugar,
-lo que te abre la puerta a querer declarar funciones sencillas sin nombre, que
-se conocen como funciones *lambda*.
+Tras un sencillo acercamiento al *scope*, has comprendido que las funciones en
+python son sólo un valor más, como puede ser un `int`, y que pueden declararse
+en cualquier lugar, lo que te abre la puerta a querer declarar funciones
+sencillas sin nombre, que se conocen como funciones *lambda*.
 
 Una vez has aclarado que las funciones son ciudadanos de primera clase
 (*first-class citizens*) ya estabas preparado para afrontar la realidad del
 *scope* donde has tratado los contextos y cómo funcionan definiendo el concepto
 del *scope léxico* que, colateralmente, te ha enseñado lo que es una *closure*,
-un método para implementarlo.
+un método para implementarlo. Pero también has tenido ocasión de aprender que
+en python es posible crear casos de *scope dinámico* mediante las sentencias
+`global` y `nonlocal`, que pueden ser útiles, pero es mejor no abusar de ellas.
 
 Pero no había quedado claro en su momento cómo funcionaban los argumentos de
 entrada y las llamadas a las funciones, así que has tenido ocasión de ver por
 primera vez lo que es un *callable* en python, aunque se te ha prometido
-analizarlo en el futuro.
-
-El último detalle que has aprendido son los tipos de argumentos de entrada que
-pueden recibir las funciones, *positional* y *keyword*, y cómo se utilizan en
-todas sus posibles formas.
+analizarlo en el futuro. Lo que sí que has tenido ocasión de tratar son los
+argumentos *positional* y *keyword*, y cómo se utilizan en todas sus posibles
+formas.
 
 Finalmente, para agrupar todo esto en un único concepto, se te han mostrado los
 *decorators*, aunque de forma muy general, con el fin de que vieras que todo lo