Corrections in first chapters

4 files changed, 116 insertions, 116 deletions

diff --git a/es/01_intro.md b/es/01_intro.md
index b2a1752..84aa8a7 100644
--- a/es/01_intro.md
+++ b/es/01_intro.md
@@ -129,8 +129,10 @@ Como ejercicio te propongo lo siguiente:
 
 1. Abre la shell de python (puedes hacerlo en IDLE o desde la shell de sistema
    ejecutando `python` o `python3`).
-2. Entra en la ayuda interactiva. PISTA: el mensaje que aparece al abrir la
-   REPL te dice cómo.
+2. Entra en la ayuda interactiva.
+
+   > PISTA: el mensaje que aparece al abrir la REPL te dice cómo.
+
 3. Sal de la ayuda (descubre tú mismo cómo se hace).
 4. Ejecuta `import this` y lee el resultado.
 
@@ -173,11 +175,10 @@ ejecutarse. Esto es interesante a la hora de probar y analizar el programa.
 ### La vida real
 
 En realidad, los programas de producción no se ejecutan en una shell como la
-que IDLE nos brinda. IDLE sólo está facilitando nuestro trabajo como
-desarrolladores, como otros entornos de desarrollo hacen, cada uno a su manera.
-En producción el código se levantará ejecutando el intérprete de python
-directamente con nuestro programa como input. Por ejemplo en la shell **de
-sistema** usando el siguiente comando.
+que IDLE nos brinda. IDLE sólo está facilitando nuestro trabajo de desarrollo,
+como otros entornos hacen, cada uno a su manera.  En producción el código se
+levantará ejecutando el intérprete de python directamente con nuestro programa
+como input. Por ejemplo en la shell **de sistema** usando el siguiente comando.
 
 ``` bash
 python ejemplo.py
diff --git a/es/02_datos.md b/es/02_datos.md
index 8400737..48c802c 100644
--- a/es/02_datos.md
+++ b/es/02_datos.md
@@ -16,11 +16,11 @@ Al igual que en las matemáticas se utilizan los símbolos para representar
 posibles valores y simplificar los procesos, en los lenguajes de programación
 se utilizan símbolos para definir referencias a los datos y así poder referirse
 a los mismos datos por su nombre sin tener que introducir su contenido
-constantemente. Los lenguajes de programación aportan al programador la
+constantemente. Los lenguajes de programación aportan a quien programa la
 facilidad de poder crear sus propios nombres para no tener que usar las
 direcciones propias de la memoria, que normalmente son número sin más
-significado que su posición, la mayor parte de las veces permitiendo al
-programador abstraerse de estos detalles internos.
+significado que su posición, la mayor parte de las veces permitiendo a quien
+programa abstraerse de estos detalles internos.
 
 En python existe un operador para declarar símbolos que hacen referencia a un
 valor: el operador `=`. Este operador enlaza el valor de la derecha con el
@@ -197,11 +197,10 @@ ejemplo, `2.999999999`, cuando debería ser `3.0`) y compararlos entre ellos
 puede ser desastroso. Para evitarlo, te recomiendo que *siempre* redondees los
 valores a una precisión que puedas controlar.
 
-Aunque realmente es algo más complejo[^1], lo que sabes ahora te evitará
-problemas en el futuro, sobre todo cuando analices datos, uno de los sectores
-donde python se usa de forma extensiva.
-
-[^1]: <https://en.wikipedia.org/wiki/Floating-point_arithmetic>
+Aunque realmente es algo más complejo, lo que sabes ahora te evitará problemas
+en el futuro, sobre todo cuando analices datos, uno de los sectores donde
+python se usa de forma extensiva. Si necesitas saber más, debes investigar la
+artimética de coma flotante, o *floating point arithmetic* en inglés.
 
 Declarar números de coma flotante es natural porque usa una sintaxis a la que
 estamos acostumbrados:
@@ -263,14 +262,12 @@ SyntaxError: invalid syntax
 ```
 
 > NOTA: la contrabarra sirve para introducir caracteres especiales o caracteres
-> de escape[^2]: `\n` salto de línea, `\t` tabulador, etc. Que son una herencia
-> de los tiempos de las máquinas de escribir, pero son aún útiles y muy usados.
+> de escape: `\n` salto de línea, `\t` tabulador, etc. Que son una herencia de
+> los tiempos de las máquinas de escribir, pero son aún útiles y muy usados.
 > Para expresar la propia contrabarra ha de escaparse a sí misma con otra
 > contrabarra para que no evalúe el siguiente caracter como un caracter de
 > escape.: `\\`.
 
-[^2]: <https://en.wikipedia.org/wiki/Escape_character>
-
 
 ### Tipos compuestos
 
@@ -301,7 +298,7 @@ En python los índices comienzan en `0`.
 Las listas o *list* son muy similares a las tuplas, pero son algo más complejas
 porque pueden alterarse así mismas. A diferencia de todos los tipos que hemos
 visto hasta ahora, tanto las listas como los diccionarios que veremos a
-continuación son mutables. Esto significa que puede transformarse su valor, más
+continuación son mutables. Esto significa que puede transformarse su valor. Más
 adelante trataremos esto en detalle.
 
 De momento, recuerda que las listas se construyen de forma similar a las
@@ -319,7 +316,7 @@ los índices es idéntica.
 
 Los diccionarios o *dictionary* son un tipo de dato similar a los dos
 anteriores, pero que en lugar de utilizar índices basados en la posición de sus
-elementos usan claves arbitrarias definidas por el usuario.
+elementos usan claves arbitrarias definidas por quien programa.
 
 Además, los diccionarios no están ordenados así que no se puede suponer que las
 claves siempre van a estar en el orden en el que se introducen.
@@ -379,8 +376,9 @@ intersecciones (*intersection*) y otros métodos descritos en esta teoría.
 ## Conversión
 
 Ahora que conoces los valores sé que quieres saber cómo cambiar de uno a otro.
-Cómo leer un Integer desde un String etc. Python tiene funciones para construir
-sus diferentes tipos de datos a partir de los diferentes inputs posibles.
+Cómo leer un Integer desde un String, etc. Python tiene funciones para
+construir sus diferentes tipos de datos a partir de los diferentes inputs
+posibles.
 
 Aunque aún no sabes ejecutar funciones te adelanto cómo se hace con algunos
 ejemplos:
@@ -427,9 +425,9 @@ cuenta la ayuda.
 Ahora que sabes el contexto en el que vas a jugar, necesitas poder alterar los
 datos.
 
-Existen operadores básicos que te permiten transformar los datos, algunos ya
-los has visto antes, el operador `=`, que sirve para nombrar cosas, la suma
-(`+`) o la resta (`-`), pero hay otros.
+Existen operadores básicos que te permiten transformar los datos. Algunos ya
+los has visto antes, como el operador `=`, que sirve para nombrar cosas, la
+suma (`+`) o la resta (`-`), pero hay otros.
 
 ``` python
 >>> 1 + 1
@@ -450,18 +448,18 @@ memorizar.
 Las pruebas de verdad generan un valor booleano desde una pareja de valores. A
 continuación una lista de las pruebas de verdad con unos ejemplos:
 
-| operator | meaning |
-|---|---|
-| <  | strictly less than |
-| <=  | less than or equal |
-| >  | strictly greater than |
-| >=  | greater than or equal |
-| ==  | equal |
-| !=  | not equal |
-| is  | object identity |
-| is not  | negated object identity |
-| in  | containment test |
-| not in  | negated containment test |
+| operador | significado                               |
+|----------|-------------------------------------------|
+| `<`      | menor que                                 |
+| `<=`     | menor o igual que                         |
+| `>`      | mayor que                                 |
+| `>=`     | mayor o igual que                         |
+| `==`     | igual que                                 |
+| `!=`     | diferente de                              |
+| `is`     | identidad de objetos: «es»                |
+| `is not` | identidad negada: «no es»                 |
+| `in`     | comprobación de contenido: «en»           |
+| `not in` | comprobación de contenido negada: «no en» |
 
 ``` python
 >>> 1 > 1
@@ -486,11 +484,11 @@ True
 Los operadores lógicos mezclan booleanos y son muy importantes, sobre todo para
 combinar las pruebas de verdad.
 
-| operator | meaning |
-|---|---|
-| and | logical and, returns True if both True, False otherwise |
-| or  | logical or, returns True if any True, False otherwise |
-| not | logical not, returns True if False, True otherwise |
+| operador | significado |
+|----------|----------------------------------------------------------|
+| `and`    | «Y» lógico, es `True` si todos sus operandos son `True`  |
+| `or`     | «O» lógico, es `True` si algún operando es `True`        |
+| `not`    | «No» lógico, invierte el operando                        |
 
 La mayor parte de los operadores son binarios (como la suma), necesitan dos
 valores y devuelven otro, pero existe al menos una excepción que funciona con
@@ -514,16 +512,16 @@ True
 Los operadores matemáticos transforman números entre ellos. Casi todos son
 conocidos por su operación matemática.
 
-| operator | meaning |
-|---|---|
-| + | addition |
-| - | subtraction or negative |
-| `*` | multiplication |
-| / | division |
-| `**` | power |
-| % | remainder |
+| operador | significado |
+|----------|----------|
+| `+`      | Suma     |
+| `-`      | Negativo o resta|
+| `*`      | Multiplicación |
+| `/`      | División |
+| `**`     | Potencia |
+| `%`      | Resto    |
 
-### Ternary operator
+### Operador ternario
 
 Existe además un operador que puede usar tres parámetros, el *inline-if* (*if
 en línea*), o *ternary operator*[^ternary]. El *ternary operator* se comporta
@@ -536,7 +534,11 @@ así:
 1
 ```
 
-[^ternary]: <https://en.wikipedia.org/wiki/%3F:#Python>
+[^ternary]: En realidad, el nombre de operador ternario no indica nada más que
+  el hecho de que use tres argumentos. Históricamente se ha usado este nombre
+  para este operador en concreto, que en otros lenguajes aparece con la forma
+  `condición ? resultado1 : resultado2`, porque no solía existir ningún otro
+  operador que recibiera tres argumentos.
 
 
 ### Operación en función del tipo
@@ -604,7 +606,7 @@ lado derecho completo obteniendo un 20 y después se asigna la referencia `b` a
 ese valor.
 
 Si queremos, después podemos reasignar el símbolo `a` a otro valor nuevo, en
-este caso al que hacer referencia `b` que es 20.
+este caso al que hacer referencia `b`, que es 20.
 
 En este primer ejemplo, ningún valor está siendo alterado, si te fijas, sólo
 estamos creando nuevos valores y cambiando las referencias a éstos.
diff --git a/es/03_estructura.md b/es/03_estructura.md
index ba9abdb..4aa6570 100644
--- a/es/03_estructura.md
+++ b/es/03_estructura.md
@@ -25,9 +25,9 @@ Para poder alterar el orden de los comandos, o elegir en función de una
 condición cuales se ejecutan, python dispone de unas estructuras. Pero, antes
 de contarte cuales son, te adelanto su forma general. Normalmente se declaran
 en una línea terminada en `:` y su cuerpo se sangra hacia dentro. La sangría (o
-indentación si lo calcamos del inglés[^indent]) es lo que define dónde empieza
-o termina un *bloque* en python. Las líneas consecutivas sangradas al mismo
-nivel se consideran el mismo *bloque*.
+indentación si lo calcamos del inglés) es lo que define dónde empieza o termina
+un *bloque* en python. Las líneas consecutivas sangradas al mismo nivel se
+consideran el mismo *bloque*.
 
 #### Bloques
 
@@ -40,12 +40,10 @@ contexto. Sirven para delimitar zonas del programa, cuerpos de sentencias, etc.
 
 Es **muy importante** sangrar los bloques correctamente, usando una sangría
 coherente. Puedes usar dos espacios, el tabulador, cuatro espacios o lo que
-desees, pero elijas lo que elijas debe ser coherente en todo el documento.
-IDLE y los editores de código en general puede configurarse para usar una
-anchura de indentación concreta, que se insertará cuando pulses la tecla
-tabulador. El estándar de python es cuatro espacios.
-
-[^indent]: <https://en.wikipedia.org/wiki/Indentation_(typesetting)>
+desees, pero elijas lo que elijas debe ser coherente en todo el documento.  Los
+editores de código, como IDLE, pueden configurarse para usar una anchura de
+indentación concreta, que se insertará cuando pulses la tecla tabulador. El
+estándar de python es cuatro espacios.
 
 ## Sintaxis general
 
@@ -74,8 +72,9 @@ print("Hola") # Esto es otro comentario
 ### Control de flujo
 
 Como ya se ha adelantado, es posible cambiar el orden de ejecución del programa
-en función de unas normas o evitar que el programa ejecute ciertas sentencias.
-A esto se le conoce como *control de flujo*.
+en función de unas normas para evitar que el programa ejecute ciertas
+sentencias o repita la ejecución de algunos bloques.  A esto se le conoce como
+*control de flujo*.
 
 #### Condicionales
 
@@ -101,8 +100,8 @@ Tal y como se muestra en el ejemplo, los bloques `elif` y el bloque `else` son
 opcionales. Es posible, y muy común además, hacer un `if` únicamente con el
 apartado inicial.
 
-Si te preguntas qué condiciones debes usar, es tan simple como usar sentencias
-de python cuyo resultado sea `True` o `False`. Cuando la sentencia resulte en
+Si te preguntas qué condiciones debes usar, es tan simple como usar expresiones
+de python cuyo resultado sea `True` o `False`. Cuando la expresión resulte en
 un `True` la condición se cumplirá y el bloque interior se ejecutará.
 
 En resumen, el *if* ejecuta el bloque *si* la condición se cumple.
@@ -200,7 +199,8 @@ True
 Es relativamente sencillo prever qué valores son *truthy* o *falsey*,
 normalmente los valores que representan un vacío se consideran `False`.
 
-[^truthy]: <https://docs.python.org/3/library/stdtypes.html#truth-value-testing>
+[^truthy]: La documentación oficial de python describe estas conversiones en
+  detalle en la sección *Truth value testing*.
 
 
 ### List comprehensions
@@ -208,7 +208,7 @@ normalmente los valores que representan un vacío se consideran `False`.
 Una de las excepciones sintácticas que sí que podemos explicar en este momento,
 en el que ya sabes hacer bucles, son las *list comprehensions*. Python dispone
 de un sistema para crear secuencias y transformarlas muy similar a la notación
-de construcción de sets de las matemáticas[^set-notation].
+de construcción de sets de las matemáticas.
 
 Como mejor se entiende es con unos ejemplos, en este caso vamos usar la función
 `range` para crear una lista de números del `0` (inclusive) al `10` (no
@@ -247,11 +247,9 @@ proceso que dejamos para el futuro.
 <generator object <genexpr> at 0x7f779d9b2d58>
 ```
 
-[^set-notation]: <https://en.wikipedia.org/wiki/Set-builder_notation>
-
 ### Excepciones
 
-Las excepciones o *exception* son errores del programa, python lanza
+Las excepciones o *exception* son errores del programa. Python lanza
 excepciones cuando hay problemas. Por ejemplo, cuando intentas acceder a un
 índice inexistente en una lista.
 
@@ -259,9 +257,9 @@ Las excepciones terminan la ejecución del programa a no ser que se gestionen.
 Se consideran fallos de los que el programa no puede arreglarse a no ser que se
 le indique cómo. Algunas funciones y librerías lanzan excepciones que nosotros
 debemos gestionar, por ejemplo: que un archivo no exista, o que no se tenga
-permisos de edición en el directorio, etc. Es nuestra responsabilidad como
-programadores tener un plan be o aceptar la excepción deportivamente a
-sabiendas que nuestro programa terminará indicando un error.
+permisos de edición en el directorio, etc. Es nuestra responsabilidad tener un
+plan be o aceptar la excepción deportivamente a sabiendas que nuestro programa
+terminará indicando un error.
 
 Hay ocasiones en las que las excepciones pueden capturarse y otras no, por
 ejemplo, los fallos de sintaxis no pueden solventarse.
@@ -314,13 +312,11 @@ capturar ninguna, perdiendo así el detalle de los fallos.
 
 Cuando aprendas sobre programación orientada a objetos en el apartado
 correspondiente puedes volver a visitar este punto y leer la documentación de
-python[^exception] para entender cómo hacerlo. Te adelanto que python tiene una
+python para entender cómo hacerlo. Te adelanto que python tiene una
 larga lista de excepciones y que está considerado una mala práctica crear
 nuevas si las excepciones por defecto cubren un caso similar al que se
 encuentra en nuestro programa.
 
-[^exception]: <https://docs.python.org/3/library/exceptions.html>
-
 ### Funciones
 
 Las funciones sirven, sobre todo, para reutilizar código. Si una pieza de
@@ -527,8 +523,8 @@ para después avanzar a las *list comprehensions*, cuyo nombre contiene *list*
 pero valen para cualquier dato complejo.
 
 Has cambiado un poco de tema después, saltando a las excepciones, que no has
-podido ver en detalle por no ser, aún, un experto en programación orientada a
-objetos. Pero tranquilo, pronto lo serás.
+podido ver en detalle por no haber visitado, aún, la programación orientada a
+objetos. Pero calma, pronto lo haremos.
 
 Una pincelada sobre funciones ha sido suficiente para que no les tengas miedo
 nunca más y que podamos atacar el siguiente capítulo con energía, ya que ahora
diff --git a/es/04_funciones.md b/es/04_funciones.md
index 618ccd6..2fd3c73 100644
--- a/es/04_funciones.md
+++ b/es/04_funciones.md
@@ -123,9 +123,10 @@ La sintaxis de una función lambda te la enseño con un ejemplo:
 3
 ```
 
-En el ejemplo primero se muestra la declaración de una función y después
-colocando los paréntesis de precedencia y después de llamada a función se
-construye una función a la izquierda y se ejecuta con los valores `1` y `2`.
+En el primer ejemplo se muestra la declaración de una función lambda. En el
+segundo, colocando los paréntesis de precedencia y después de llamada a
+función, se construye una función lambda y después se ejecuta con los valores
+`1` y `2`.
 
 Es fácil de entender la sintaxis de la función lambda, básicamente es una
 función reducida de sólo una sentencia con un `return` implícito.
@@ -160,9 +161,7 @@ Las funciones lambda se usan un montón como *closure*, un concepto donde el
 *scope* se trabaja más allá de lo que hemos visto. Sigamos visitando el
 *scope*, para entender sus usos más en detalle.
 
-[^lambda]: Toman su nombre del Lambda
-  Calculus:  
-  <https://en.wikipedia.org/wiki/Deductive_lambda_calculus>
+[^lambda]: Toman su nombre del *Lambda Calculus*.
 
 ## Scope avanzado
 
@@ -189,11 +188,13 @@ pero sí al revés. Los casos son los siguientes:
 - Los módulos. Ver capítulo correspondiente
 - Las clases. Ver capítulo de Programación Orientada a Objetos.
 - Las funciones, incluidas las funciones anónimas o lambda.
-- Las expresiones generadoras[^generator-expression], que normalmente se
-  encuentran en las *list-comprehension* que ya se han tratado en el capítulo
-  previo.
+- Las expresiones generadoras definidas en el PEP-289[^pep289], que normalmente
+  se encuentran en las *list-comprehension* que ya se han tratado en el
+  capítulo previo.
 
-[^generator-expression]: <https://www.python.org/dev/peps/pep-0289/>
+[^pep289]: Los PEP son documentos donde se proponen mejoras para el lenguaje.
+  Puedes leer el contenido completo del PEP en:  
+  <https://www.python.org/dev/peps/pep-0289/>
 
 
 ### Scope léxico, Closures
@@ -212,9 +213,9 @@ def create_incrementer_function(increment):
     return incrementer
 
 increment10 = create_incrementer_function(10)
-increment10(10)   # Returns 20
+increment10(10)   # 20
 increment1 = create_incrementer_function(1)
-increment1(10)    # Returns 11
+increment1(10)    # 11
 ```
 En este ejemplo hemos creado una función que construye funciones que sirven
 para incrementar valores.
@@ -269,7 +270,7 @@ 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.
 
-### `global` y `nonlocal`
+### Global y No-local
 
 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
@@ -345,11 +346,10 @@ 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*
-en casos extraños. 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.
+Las sentencias `global` y `nonlocal` son tramposas, ya que dificultan la
+comprensión del programa. La mejor recomendación que puede hacerse es tratar de
+evitarlas. Usarlas en exceso es, en general, un indicador de un mal diseño de
+programa.
 
 ## Argumentos de entrada y llamadas
 
@@ -388,9 +388,9 @@ TypeError: 'int' object is not callable
 #### Caso de estudio: Switch Case
 
 Si quieres ver un ejemplo avanzado de esto, te propongo la creación de la
-estructura *switch-case* [^switch-case], que puede encontrarse en otros
-lenguajes, pero que en lugar de usar una estructura basada en un *if* con
-múltiples *elif* uses un diccionario de funciones.
+estructura *switch-case*, que puede encontrarse en otros lenguajes, pero que en
+lugar de usar una estructura basada en un *if* con múltiples *elif* uses un
+diccionario de funciones.
 
 Las funciones son valores, por lo que pueden ocupar un diccionario como
 cualquier otro valor. Construyendo un diccionario en cuyas claves se encuentran
@@ -425,8 +425,6 @@ except KeyError:
 
 ```
 
-[^switch-case]: <https://en.wikipedia.org/wiki/Switch_statement>
-
 ### Positional vs Keyword Arguments
 
 Las funciones tienen dos tipos de argumentos de entrada, aunque sólo hayamos
@@ -435,9 +433,11 @@ mostrado uno de ellos de momento.
 El que ya conoces se denomina *positional argument* y se refiere a que son
 argumentos que se definen en función de su posición. Los argumentos
 posicionales deben ser situados siempre en el mismo orden, si no, los
-resultados de la función serán distintos. Las referencias `source` y `target`
-toman el primer argumento y el segundo respectivamente. Darles la vuelta
-resulta en el resultado opuesto al que se pretendía.
+resultados de la función serán distintos.
+
+Observa el siguiente ejemplo. Las referencias `source` y `target` toman el
+primer argumento y el segundo respectivamente. Darles la vuelta resulta en el
+resultado opuesto al que se pretendía.
 
 ``` python
 def move_file ( source, target ):
@@ -459,7 +459,7 @@ argumentos con nombre. No se han utilizado valores por defecto especiales, pero
 pueden usarse otros.
 
 ``` python
-def move_file( source=None, target=None):
+def move_file(source=None, target=None):
     "Mueve archivo de `source` a `target"
     pass
 
@@ -479,7 +479,7 @@ También es posible declarar funciones que acepten cualquier cantidad de
 argumentos de un tipo u otro. Ésta es la sintaxis:
 
 ``` python
-def argument_catcher( *args, **kwargs )
+def argument_catcher( *args, **kwargs ):
     "Función ejecutable con cualquier número de argumentos de entrada, tanto
     posicionales como con nombre."
     print( args )
@@ -497,7 +497,7 @@ se capturan en una tupla y los argumentos con nombre en un diccionario.
 Este tipo de funciones multiargumento se utilizan mucho en los *decorators*,
 caso que estudiaremos al final de este capítulo.
 
-#### Peligro: Mutable Defaults
+#### Peligro: mutable defaults
 
 Existe un caso en el que tienes que tener mucho cuidado. Los valores por
 defecto en los argumentos con nombre se memorizan de una ejecución de la
@@ -527,6 +527,9 @@ que es en la sentencia `def` donde aparecen.
 
 ## Decorators
 
+> TODO: CAMBIAR EL EJEMPLO POR UNA DE CONTEO DE TIEMPO
+> Así se verá la aplicación de los argumentos generales.
+
 Los *decorators* son un concepto que, a pesar de ser bastante concreto, nos
 permite descubrir todo el potencial de lo que se acaba de tratar en este
 apartado. Sirven para dotar a las funciones de características adicionales.
@@ -634,17 +637,15 @@ 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. 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.
+(*first-class citizens*) ya era momento de 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.
 
 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. Lo que sí que has tenido ocasión de tratar son los
+analizarlo en el futuro. Lo que sí que has tratado en profundidad son los
 argumentos *positional* y *keyword*, y cómo se utilizan en todas sus posibles
 formas.