add highlighting to repl stuff

1 files changed, 23 insertions, 23 deletions

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!"