add highlighting to repl stuff

4 files changed, 39 insertions, 39 deletions

diff --git a/src/01_intro.md b/src/01_intro.md
index 087406e..db3d28b 100644
--- a/src/01_intro.md
+++ b/src/01_intro.md
@@ -115,14 +115,14 @@ comportamiento de este ciclo a las mil maravillas:
 
 Por tanto, si introduces un valor directamente será devuelto:
 
-```
+``` python
 >>> 1
 1
 ```
 
 Y si lo alteras devuelve el resultado correspondiente:
 
-```
+``` python
 >>> 2+2
 4
 ```
@@ -161,7 +161,7 @@ con la orden `print`.
 Para entender el valor de la REPL, te sugiero que vayas a su ventana, y justo
 después del resultado de la ejecución hagas lo siguiente:
 
-```
+``` python
 Hola, Guido
 >>> nombre
 'Guido'
@@ -181,7 +181,7 @@ 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/src/02_datos.md b/src/02_datos.md
index 96bab25..a794c13 100644
--- a/src/02_datos.md
+++ b/src/02_datos.md
@@ -27,7 +27,7 @@ valor: el operador `=`. Este operador enlaza el valor de la derecha con el
 nombre de la izquierda. Con un ejemplo es más fácil de comprender. Probando en
 la REPL:
 
-```
+``` python
 >>> a = 10
 >>> a
 10
@@ -41,7 +41,7 @@ adelante se puede utilizar `a` para hacer referencia al valor enlazado.
 Las referencias han de ser declaradas antes de usarse, si no, el intérprete no
 las conoce y lanza una excepción:
 
-```
+``` python
 >>> b
 Traceback (most recent call last):
   File "<pyshell#6>", line 1, in <module>
@@ -131,7 +131,7 @@ usar un número entero puedes introducirlo tal cual. Recuerda que hay enteros
 positivos y negativos. El símbolo para marcar números negativos en python es el
 `-`, que coincide con el operador de la resta.
 
-```
+``` python
 >>> 14
 14
 >>> -900
@@ -143,7 +143,7 @@ Los números enteros también pueden expresarse en otras bases, como en
 hexadecimal. Dependiendo de la aplicación en la que te encuentres igual
 necesitas mirarlo más en detalle:
 
-```
+``` python
 >>> 0x10
 16
 ```
@@ -204,7 +204,7 @@ donde python se usa de forma extensiva.
 Declarar números de coma flotante es natural porque usa una sintaxis a la que
 estamos acostumbrados:
 
-```
+``` python
 >>> 1E10
 10000000000.0
 >>> 1.0
@@ -221,7 +221,7 @@ Python soporta números complejos y los expresa utilizando la letra `j`. Como
 suponen un caso bastante concreto no los analizaremos en detalle. Pero tienes
 disponible la documentación de python para lo que quieras.
 
-```
+``` python
 >>> 1-23j
 (1-23j)
 ```
@@ -238,7 +238,7 @@ longitud 1.
 Los strings se expresan rodeando texto con comillas dobles, `"`, o simples `'`
 (el símbolo del apóstrofe).
 
-```
+``` python
 >>> "Hola"
 'Hola'
 >>> 'Hola'
@@ -251,7 +251,7 @@ contenido. También puede utilizarse la contrabarra `\` para cancelar la acción
 de las comillas.
 
 
-```
+``` python
 >>> "Tiene un apóstrofe: Luke's"
 "Tiene un apóstrofe: Luke's"
 >>> 'Tiene un apóstrofe: Luke's'
@@ -286,7 +286,7 @@ Se declaran utilizando paréntesis añadiendo sus elementos separados por comas.
 Y se accede a sus contenidos utilizando los corchetes e introduciendo el índice
 del elemento que se quiere extraer.
 
-```
+``` python
 >>> (2, 3, "HOLA")
 (2, 3, 'HOLA')
 >>> (2, 3, "HOLA")[0]
@@ -306,7 +306,7 @@ De momento, recuerda que las listas se construyen de forma similar a las
 tuplas, pero utilizando corchetes en lugar de paréntesis. La forma de acceder a
 los índices es idéntica.
 
-```
+``` python
 >>> [2, 3, "HOLA"]
 [2, 3, 'HOLA']
 >>> [2, 3, "HOLA"][0]
@@ -331,7 +331,7 @@ acceder.
 Los diccionarios, al igual que las listas, son mutables. Como veremos en
 seguida.
 
-```
+``` python
 >>> {"nombre": "Guido", "apellido": "Van Rossum", "popularidad": 8.0}
 {'nombre': 'Guido', 'apellido': 'Van Rossum', 'popularidad': 8.0}
 >>> {"nombre": "Guido", "apellido": "Van Rossum", "popularidad": 8.0}["popularidad"]
@@ -356,7 +356,7 @@ valores, el set es el tipo de dato que estás buscando.
 Los sets se declaran también usando las llaves, como un diccionario, pero no
 usan claves.
 
-```
+``` python
 >>> {"a", "b", 1}
 {'a', 1, 'b'}
 ```
@@ -370,7 +370,7 @@ sus diferentes tipos de datos a partir de los diferentes inputs posibles.
 Aunque aún no sabes ejecutar funciones te adelanto como se hace con algunos
 ejemplos:
 
-```
+``` python
 >>> bool(1)
 True
 >>> bool(0)
@@ -416,7 +416,7 @@ 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.
 
-```
+``` python
 >>> 1 + 1
 2
 >>> 10 - 9
@@ -448,7 +448,7 @@ continuación una lista de las pruebas de verdad con unos ejemplos:
 | in  | containment test |
 | not in  | negated containment test |
 
-```
+``` python
 >>> 1 > 1
 False
 >>> 1 >= 1
@@ -472,7 +472,7 @@ 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
 un único valor. El operador `not` sirve para darle la vuelta a un Booleano.
 
-```
+``` python
 >>> not True
 False
 >>> True and True
@@ -505,7 +505,7 @@ 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
 así:
 
-```
+``` python
 >>> 1 if 1 > 9 else 9
 9
 >>> 1 if 1 < 9 else 9
@@ -523,7 +523,7 @@ matemáticos están preparados para trabajar sobre números (de cualquier tipo)
 pero la verdad es que algunos pueden ejecutarse sobre otros formatos. Por
 ejemplo:
 
-```
+``` python
 >>> "a" + "a"
 'aa'
 ```
@@ -545,7 +545,7 @@ resuelve de forma ordenada. Si generas una operación muy compleja, python la
 irá desgranando paso a paso y resolviendo las parejas una a una, cuanto más te
 acostumbres a hacerlo en tu mente menos errores cometerás.
 
-```
+``` python
 >>> 8 + 7 * 10 == (8 + 7) * 10
 False
 >>> 8 + 7 * 10
@@ -562,7 +562,7 @@ Ya adelantamos que el operador `=` sirve para nombrar cosas. Ahora vamos a
 combinar esa propiedad con la mutabilidad, o la propiedad de las cosas de
 alterarse a sí mismas. Empecemos con un ejemplo:
 
-```
+``` python
 >>> a = 10
 >>> b = a + 10
 >>> b
@@ -585,7 +585,7 @@ estamos creando nuevos valores y cambiando las referencias a éstos.
 
 Con los datos mutables podemos alterar los valores. Lo vemos con otro ejemplo:
 
-```
+``` python
 >>> a = {}
 >>> b = a
 >>> a["cambio"] = "hola!"
@@ -607,7 +607,7 @@ a sí mismas, pero nunca podría hacerse en tuplas, porque son inmutables.
 
 Si intentásemos un ejemplo similar en tupla, no nos dejaría:
 
-```
+``` python
 >>> a = ()
 >>> b = a
 >>> a[0] = 1
@@ -627,7 +627,7 @@ de los cambios que ocurran en ésta. Aquí ya no estamos haciendo referencia
 desde `b` a los datos que había en `a`, sino a una copia de éstos, almacenada
 en otro lugar.
 
-```
+``` python
 >>> a = {}
 >>> b = dict(a)
 >>> a["cambio"] = "hola!"
diff --git a/src/03_estructura.md b/src/03_estructura.md
index 2060cf5..7fb77a3 100644
--- a/src/03_estructura.md
+++ b/src/03_estructura.md
@@ -153,7 +153,7 @@ una sentencia de preparación. Si la preparación falla el bucle se rompe.
 El uso más común del `for` es el de iterar en secuencias gracias al operador
 `in` que mencionamos anteriormente pero que en este caso toma un uso distinto:
 
-```
+``` python
 >>> for i in [0,1,2,3]:
 ...     i+2
 ... 
@@ -184,7 +184,7 @@ resultado `True` será considerado verdadero y viceversa. A estos valores se les
 conoce habitualmente como *truthy* y *falsey* porque no son `True` o `False`
 pero se comportan como si lo fueran. Algunos ejemplos curiosos:
 
-```
+``` python
 >>> bool([])
 False
 >>> bool(None)
@@ -214,7 +214,7 @@ 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
 inclusive). Usando la ayuda puedes saber más sobre la función `range`.
 
-```
+``` python
 >>> [i**2 for i in range(0, 10)]
 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 >>> tuple(i**2 for i in range(0, 10))
@@ -242,7 +242,7 @@ 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.
 
-```
+``` python
 >>> (i**2 for i in range(0, 10))
 <generator object <genexpr> at 0x7f779d9b2d58>
 ```
@@ -410,7 +410,7 @@ por la razón que sea, debes usar `pass` en su interior porque, si no lo haces y
 simplemente lo dejas vacío, la sintaxis será incorrecta y python lanzará una
 excepción grave diciéndote que esperaba un bloque con sangría y no se lo diste.
 
-```
+``` python
 >>> if True:
 ... 
   File "<stdin>", line 2
@@ -438,7 +438,7 @@ condición para decidir si volver a ejecutarlo.
 
 En el siguiente ejemplo salta la ejecución para el caso en el que `i` es `2`.
 
-```
+``` python
 >>> for i in [0, 1, 2, 3]:
 ...     if i == 2:
 ...             continue
@@ -455,7 +455,7 @@ En el siguiente ejemplo salta la ejecución para el caso en el que `i` es `2`.
 ejecutar la siguiente sentencia, simplemente se rompe el bucle completo. En el
 siguiente ejemplo se rompe el bucle cuando `i` es `2` y no se recupera.
 
-```
+``` python
 >>> for i in [0, 1, 2, 3]:
 ...     if i == 2:
 ...             break
diff --git a/src/04_funciones.md b/src/04_funciones.md
index 1779c3f..7cee36c 100644
--- a/src/04_funciones.md
+++ b/src/04_funciones.md
@@ -15,7 +15,7 @@ def inc(a):
 
 Si lanzamos:
 
-```
+``` python
 >>> inc(1)
 2
 >>> inc(10)
@@ -24,7 +24,7 @@ Si lanzamos:
 
 Si preguntamos por `b`:
 
-```
+``` python
 >>> b
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
@@ -115,7 +115,7 @@ oficial de python las define como funciones para vagos.
 
 La sintaxis de una función lambda te la enseño con un ejemplo:
 
-```
+``` python
 >>> lambda x, y: x+y
 <function <lambda> at 0x7f035b879950>
 >>> (lambda x, y: x+y)(1,2)
@@ -216,7 +216,7 @@ 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 
@@ -238,7 +238,7 @@ 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