summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorEkaitz Zarraga <ekaitz@elenq.tech>2019-11-23 19:45:04 +0100
committerEkaitz Zarraga <ekaitz@elenq.tech>2019-11-23 19:45:04 +0100
commit4d73b41553d9284f8cd79fa954dc3ea662ec0ee5 (patch)
treec990ebd3f5ab6223cf48e1d5976f87a900dd7360
parentdd8ca8090720e30239c89c6705772ae1b29d628c (diff)
add highlighting to repl stuff
-rw-r--r--src/01_intro.md8
-rw-r--r--src/02_datos.md46
-rw-r--r--src/03_estructura.md14
-rw-r--r--src/04_funciones.md10
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