Corrections by Nuria from Casa Tia Julia my idol of the world

5 files changed, 49 insertions, 48 deletions

diff --git a/es/01_intro.md b/es/01_intro.md
index 254f4e7..3479aa4 100644
--- a/es/01_intro.md
+++ b/es/01_intro.md
@@ -48,7 +48,7 @@ sudo apt-get install python3 python3-pip idle3
 
 ### Instalación en otros sistemas
 
-Como siempre instalar en otros sistemas es más farragoso. Pero no es demasiado
+Como siempre, instalar en otros sistemas es más farragoso. Pero no es demasiado
 difícil en este caso. La instalación puede realizarse con una descarga desde la
 página web oficial de python:
 
@@ -56,7 +56,7 @@ página web oficial de python:
 
 Una vez ahí seleccionar la versión necesaria, descargar el instalador y seguir
 las instrucciones de éste. Recuerda seleccionar **instalar pip** entre las
-opciones y activar la casilla de **añadir python al PATH**, que permitirá que
+opciones y activar la casilla de **añadir python al PATH**, que permitirá
 que ejecutes programas de python sin problemas. También puedes añadir
 **IDLE**, el programa que sirve para editar el código, pero te recuerdo que
 es un programa muy sencillo, que nos servirá para entender lo básico del
@@ -75,11 +75,10 @@ peculiaridades, pero ésta es la principal y la más usada.
 
 Como intérprete que es, python es capaz de leer un archivo escrito en su
 lenguaje y ejecutar sus órdenes en tu computadora. Ésta es principalmente su
-labor. Sin embargo, también es capaz de realizar esta operación de forma
-interactiva recibiendo las órdenes una por una y devolviendo el resultado de su
-ejecución como respuesta. Este proceso se conoce como REPL, acrónimo de
-read-eval-print-loop (lee-evalúa-imprime-repite), aunque en otros lugares se le
-conoce como la shell de python.
+labor. Sin embargo, también es capaz de recibir las órdenes una por una y
+devolver el resultado de su ejecución como respuesta. Este proceso se conoce
+como REPL, acrónimo de read-eval-print-loop (lee-evalúa-imprime-repite), aunque
+en otros lugares se le conoce como la shell de python.
 
 >  La shell de python (o REPL) y la shell del sistema son cosas
 > diferentes. La shell de sistema también es un intérprete pero del lenguaje
@@ -101,15 +100,16 @@ cuando la termines pulsando la tecla `ENTER` de tu teclado, recibirás el
 resultado de la ejecución de la orden insertada. El acrónimo REPL define el
 comportamiento de este ciclo a las mil maravillas:
 
->  En este documento, siempre que veas el símbolo `>>>` significa que se
-> trata de un ejemplo ejecutado en la REPL. Si no lo ves, se tratará del
-> contenido de un archivo de código python ejecutado de forma independiente.
-
 1. Lee lo que introduces.
 2. Lo evalúa, obteniendo así un valor como resultado.
 3. Lo imprime.
 4. Repite el ciclo volviendo a leer.
 
+>  En este documento, siempre que veas el símbolo `>>>` significa que se
+> trata de un ejemplo ejecutado en la REPL. Si no lo ves, se tratará del
+> contenido de un archivo de código python ejecutado de forma independiente.
+
+
 Por tanto, si introduces un valor directamente será devuelto:
 
 ``` python
diff --git a/es/02_datos.md b/es/02_datos.md
index 9006d2b..c7a39cc 100644
--- a/es/02_datos.md
+++ b/es/02_datos.md
@@ -10,7 +10,7 @@ imaginarte la memoria como un conjunto de cajas identificadas con direcciones,
 como si fuesen los buzones de un portal con muchos pisos. Para utilizar datos,
 éstos se guardan en los diferentes cajones y se van extrayendo y actualizando.
 La importancia de nombrar las cosas es evidente, si no guardamos un listado de
-dónde hemos guardado qué no podemos recuperar los datos que hemos creado.
+dónde hemos guardado qué, no podemos recuperar los datos que hemos creado.
 
 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
@@ -18,7 +18,7 @@ se utilizan símbolos para definir referencias a los datos y así poder referirs
 a los mismos datos por su nombre sin tener que introducir su contenido
 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
+direcciones propias de la memoria, que normalmente son números sin más
 significado que su posición, la mayor parte de las veces permitiendo a quien
 programa abstraerse de estos detalles internos.
 
@@ -68,9 +68,10 @@ valores. Es muy común tener muchas referencias a la misma estructura de datos y
 transformar su contenido desde todas las referencias.
 
 A nivel técnico, lo que en python se conoce como variable y en este documento
-hemos hecho el esfuerzo de llamar referencia es lo que en otros lenguajes se
-conoce como un puntero y la labor del operador `=` es la de asignar el puntero
-a la dirección donde se encuentran los datos a los que debe apuntar.
+hemos hecho el esfuerzo de llamar, hasta este momento, referencia es parecido a
+lo que en otros lenguajes se conoce como puntero y la labor del operador `=` es
+la de asignar el puntero a la dirección donde se encuentran los datos a los que
+debe apuntar.
 
 Volviendo a la metáfora de los buzones, en lenguajes de más bajo nivel como C
 estás obligado a seleccionar qué buzón vas a utilizar para introducir cada
@@ -351,7 +352,7 @@ peculiaridades:
 
 - Sus valores son únicos. No pueden repetirse.
 - No están ordenados.
-- No pueden accederse mediante los corchetes (`[]`).
+- No se puede acceder a ellos mediante los corchetes (`[]`).
 
 Estas dos características tan estrictas, lejos de ser limitantes, aportan una
 mejora radical en su rendimiento. Buscar elementos en un set es extremadamente
diff --git a/es/03_estructura.md b/es/03_estructura.md
index 1ff4a92..9c24fb1 100644
--- a/es/03_estructura.md
+++ b/es/03_estructura.md
@@ -23,7 +23,7 @@ que lo ejecutes y siempre salen los resultados en el mismo orden.
 
 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
+de contarte cuáles 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) es lo que define dónde empieza o termina
 un *bloque* en python. Las líneas consecutivas sangradas al mismo nivel se
@@ -80,7 +80,7 @@ sentencias o repita la ejecución de algunos bloques.  A esto se le conoce como
 
 Las condicionales son herramientas de *control de flujo* que permiten separar
 la ejecución en diferentes ramas en función de unas condiciones. En python sólo
-existe el condicional `if` («si», en castellano), aunque existen otras
+existe el condicional `if` («si», en castellano); aunque existen otras
 estructuras para conseguir el mismo efecto, no las trataremos aún.
 
 Ésta es la sintaxis del `if`:
@@ -237,7 +237,7 @@ poderosas que eso, pudiendo a llegar a complicarse sobremanera añadiendo
 condiciones, como en el último de los ejemplos, para filtrar algunos casos.
 
 Te habrá mosqueado el uso de `tuple` para crear la tupla. Todo tiene una razón.
-La tupla, al estar formada por paréntesis, python no tiene claro si son
+En la tupla, al estar formada por paréntesis, python no tiene claro si son
 paréntesis de precedencia o de creación de tupla, y considera que son los
 primeros, dando como resultado un generador, un paso intermedio de nuestro
 proceso que dejamos para el futuro.
@@ -254,15 +254,15 @@ excepciones cuando hay problemas. Por ejemplo, cuando intentas acceder a un
 índice inexistente en una lista.
 
 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 tener un
-plan be o aceptar la excepción deportivamente a sabiendas que nuestro programa
-terminará indicando un error.
+Se consideran fallos de los que el programa no se puede recuperar 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
+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.
+Hay ocasiones en las que las excepciones pueden capturarse y otras en las que
+no; por ejemplo, los fallos de sintaxis no pueden solventarse.
 
 Las excepciones se capturan con un `try-except` que, si programas en otros
 lenguajes como Java, probablemente conozcas como `try-catch`.
@@ -326,7 +326,7 @@ el código fuente. Aunque sirven para más fines y tienen detalles que
 aclararemos en un capítulo propio, en este apartado adelantaremos cómo se
 definen y cómo lanzan y posteriormente las analizaremos en detalle.
 
-Las definición de funciones se realiza con una estructura similar a las
+La definición de funciones se realiza con una estructura similar a las
 anteriores, una línea descriptiva terminada en dos puntos (`:`) y después un
 bloque con mayor sangría para definir el cuerpo.
 
diff --git a/es/04_funciones.md b/es/04_funciones.md
index 81aeb8e..444ae63 100644
--- a/es/04_funciones.md
+++ b/es/04_funciones.md
@@ -37,11 +37,11 @@ Parece que no conoce el nombre `b`. Esto es un tema relacionado con el *scope*.
 ## Scope
 
 Anteriormente se ha dicho que python es un lenguaje de programación con gestión
-automática de la memoria. Esto significa que él mismo es capaz de saber cuando
-necesita pedir más memoria al sistema operativo y cuando quiere liberarla.
+automática de la memoria. Esto significa que él mismo es capaz de saber cuándo
+necesita pedir más memoria al sistema operativo y cuándo quiere liberarla.
 El *scope* es un resultado este sistema. Para que python pueda liberar
 memoria, necesita de un proceso conocido como *garbage collector* (recolector
-de basura), que se encarga de buscar cuando las referencias ya no van a poder
+de basura), que se encarga de buscar cuándo las referencias ya no van a poder
 usarse más para pedir una liberación de esa memoria. Por tanto, las referencias
 tienen un tiempo de vida, desde que se crean hasta que el recolector de basura
 las elimina. Ese tiempo de vida se conoce como *scope* y, más que en tiempo, se
@@ -169,14 +169,14 @@ Cada vez que se crea una función, python crea un nuevo contexto para ella.
 Puedes entender el concepto de contexto como una tabla donde se van guardando
 las referencias que se declaran en la función. Cuando la función termina, su
 contexto asociado se elimina, y el recolector de basura se encarga de liberar
-la memoria de sus variables, tal y como vimos anteriormente.
+la memoria de sus referencias, tal y como vimos anteriormente.
 
 Lo que ocurre es que estos contextos son jerárquicos, por lo que, al crear una
 función, el padre del contexto que se crea es el contexto de la función madre.
 Python utiliza esto como método para encontrar las referencias. Si una
 referencia no se encuentra en el contexto actual, python la buscará en el
 contexto padre y así sucesivamente hasta encontrarla o lanzar un error diciendo
-que no la conoce. Esto explica por qué las variables declaradas en la función
+que no la conoce. Esto explica por qué las referencias declaradas en la función
 madre pueden encontrarse y accederse y no al revés.
 
 Aunque hemos explicado el *scope* como un concepto asociado a las funciones, la
@@ -224,7 +224,7 @@ Las funciones devueltas viven durante más tiempo que la función que las
 albergaba por lo que saber qué pasa con la variable `increment` es difícil a
 simple vista.
 
-Python no destruirá ninguna variable que todavía pueda ser accedida, si lo
+Python no destruirá ninguna variable a la que todavía se pueda acceder, si lo
 hiciera, las funciones devueltas no funcionarían porque no podrían incrementar
 el valor. Habrían olvidado con qué valor debían incrementarlo.
 
@@ -372,7 +372,7 @@ los campos de una colección usando los corchetes, siempre que python se
 encuentre unos paréntesis después de un valor tratará de ejecutar el valor. Así
 que los paréntesis no son una acción que únicamente pueda aplicarse en nombres
 de función[^lambdas-ejemplo] y python no lanzará un fallo de sintaxis cuando
-los usemos fuera de lugar, si no que será un fallo de tiempo de ejecución al
+los usemos fuera de lugar, sino que será un fallo de tiempo de ejecución al
 darse cuenta de lo que se intenta ejecutar no es ejecutable.
 
 ``` python
@@ -575,7 +575,7 @@ sugar*[^syntactic-sugar].
 
 Los *decorators* pueden entenderse como un envoltorio para una función. No son
 más que una función que devuelve otra. En el caso del decorador del ejemplo, el
-*decorator* `timer` es función que recibe otra función como argumento de
+*decorator* `timer` es una función que recibe otra función como argumento de
 entrada y devuelve la función `decorated_function`. Este decorador, al
 aplicarlo a una función con `@timer` está haciendo lo siguiente:
 
diff --git a/es/05_oop.md b/es/05_oop.md
index e45fdfd..fc0a538 100644
--- a/es/05_oop.md
+++ b/es/05_oop.md
@@ -10,7 +10,7 @@ corresponden más con un lenguaje de programación funcional, en python todo
 
 Python usa una programación orientada a objetos basada en clases, a diferencia
 de otros lenguajes como JavaScript, donde la orientación a objetos está basada
-en prototipos. No es el objetivo de este documento el de contarte cuales son
+en prototipos. No es el objetivo de este documento el de contarte cuáles son
 las diferencias entre ambas, pero es interesante que sepas de su existencia, ya
 que es una de las pocas diferencias que existen entre estos dos lenguajes de
 amplio uso en la actualidad.
@@ -356,7 +356,7 @@ objetos de la clase, así que hay que tener cuidado.
 
 El acceso es idéntico al que ocurriría en un valor asociado al objeto, como en
 el caso `name` del ejemplo, pero en este caso observas que en su declaración en
-la clase no es necesario indicar `self`, ya no es necesario decir cuál es la
+la clase no es necesario indicar `self`. No es necesario decir cuál es la
 instancia concreta a la que se le asigna el valor: se le asigna a todas.
 
 A parte de poder acceder a través de los objetos de la clase, es posible
@@ -378,8 +378,8 @@ que este campo no debe accederse desde el exterior de la clase y su objetivo es
 usarlo desde el interior de ésta.
 
 Esta convención se llevó al extremo en algún momento y se decidió crear un caso
-en el que esta convención inicial tuviera cierta funcionalidad añadida para las
-dobles barras bajas (`__`) que impidiera un acceso accidental a esos campos
+en el que esta convención inicial tuviera cierta funcionalidad añadida para el
+doble guión bajo (`__`) que impidiera un acceso accidental a esos campos
 conocido como *name mangling*.
 
 #### Campos privados: *name mangling*
@@ -390,7 +390,7 @@ entra por accidente a las secciones que empiezan por `__`. Añade
 dificultando el acceso por accidente.
 
 Ese acceso accidental no sólo es para que quien programa no acceda, ya que, si
-se esfuerza la suficiente, va a poder hacerlo de igual modo, si no para que el
+se esfuerza la suficiente, va a poder hacerlo de igual modo, sino para que el
 propio python no acceda al campo que no corresponde. El hecho de añadir el
 nombre de la clase al campo crea una brecha en la herencia, haciendo que los
 campos no se hereden de la forma esperada.
@@ -468,7 +468,7 @@ las clases se les puede indicar qué interfaces implementan y el lenguaje se
 encarga de asegurarse de que quien programa ha hecho todo como debe.
 
 El dinamismo de python hace que esto sea mucho más flexible. Debido a que
-python no hace casi comprobaciones antes de ejecutarse, necesita un método para
+python no hace casi comprobaciones antes de ejecutarse, necesita un método
 mucho más directo. Python aplica lo que se conoce como *duck typing* (el tipado
 del pato), es decir, *si anda como un pato, vuela como un pato y nada como un
 pato: es un pato*.
@@ -687,7 +687,7 @@ El método `__init__` es uno de los más usados e interesantes de esta lista, es
 es la razón por la que ha aparecido en más de una ocasión durante este
 capítulo.
 
-El método `__init__` es a quién se llama al crear nuevas instancias de una
+El método `__init__` es a quien se llama al crear nuevas instancias de una
 clase y sirve para *ini*cializar las propiedades del recién creado objeto.
 
 Cuando se crean nuevos objetos, python construye su estructura en memoria,
@@ -804,7 +804,7 @@ se muestra la equivalencia entre la sentencia `with` y el uso de `__enter__`,
 
 ### *Llamable*
 
-Queda pendiente desde el capítulo sobre funciones, responder a lo que es un
+Queda pendiente desde el capítulo sobre funciones responder a qué es un
 *callable* o *llamable*. Una vez llegados a este punto, tiene una respuesta
 fácil: un *llamable* es un objeto que soporta el método `__call__`.
 
@@ -829,11 +829,11 @@ argumentos como ya hemos visto en apartados anteriores, pero el primero será el
 propio objeto que está siendo llamado, el `self` que ya conocemos.
 
 Resumiendo, el método `__call__` describe cómo se comporta el objeto cuando se
-le aplican las paréntesis.
+le aplican los paréntesis.
 
 ### *Subscriptable*
 
-Tal y como el método anterior describía cómo se aplican las paréntesis a un
+Tal y como el método anterior describía cómo se aplican los paréntesis a un
 objeto, los métodos que se muestran en este apartado describen el
 comportamiento del objeto cuando se le aplican los corchetes. Recordando el
 capítulo sobre datos, los corchetes sirven para acceder a valores de las
@@ -847,7 +847,7 @@ se llama al método `__delitem__`.
 
 Aunque en otros conjuntos de métodos aquí descritos hemos inventado un nombre
 para este documento, Python denomina a este comportamiento *subscriptable* así
-que cuando intentes acceder usando corchetes a un objeto que no soporta ésta
+que cuando intentes acceder usando corchetes a un objeto que no soporta esta
 funcionalidad, el error que saltará utilizará la misma nomenclatura que
 nosotros.