1 files changed, 110 insertions, 1 deletions
diff --git a/src/03_estructura.md b/src/03_estructura.md
index 9914548..91c128e 100644
--- a/src/03_estructura.md
+++ b/src/03_estructura.md
@@ -324,8 +324,79 @@ encuentra en nuestro programa.
 
 ### Funciones
 
-TODO
+Las funciones sirven, sobre todo, para reutilizar código. Si una pieza de
+código se utiliza en más de una ocasión en tu programa, es una buena candidata
+para agruparse en una función y poder reutilizarla sin necesidad de copiar y
+pegar 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
+anteriores, una línea descriptiva terminada en dos puntos (`:`) y después un
+bloque con mayor sangría para definir el cuerpo.
+
+``` python
+def nombre_de_funcion (argumentos):
+    """
+    docstring, un string multilínea que sirve como documentación
+    de la función. Es opcional y no tiene efecto en el funcionamiento
+    de la función.
+    Es lo que se visualiza al ejecutar `help(nombre_de_función)`
+    """
+    # Cuerpo de la función
+```
+
+Para llamar a esta función que acabamos de crear:
+
+``` python
+nombre_de_función(argumentos)
+```
+
+El nombre de la función debe cumplir las mismas normas que los nombres de las
+referencias de las que ya hemos hablando anteriormente. Y esto debe ser así
+básicamente porque... ¡el nombre de la función también es una referencia a un
+valor de tipo función!
+
+Pronto ahondaremos más en este tema. De momento recuerda la declaración de las
+funciones. Dentro de ellas podrás incluir todas las estructuras definidas en
+este apartado, incluso podrás definir funciones.
+
+Aunque en el próximo capítulo tocará hablar de los argumentos de entrada, de
+momento te adelanto que cuando llamaste a la función `range` anteriormente, le
+introdujiste dos argumentos. Esos dos argumentos deben declararse como
+argumentos de entrada. Probablemente de una forma similar a esta:
+
+``` python
+def range (inicio, fin):
+    contador = inicio
+    salida = []
+    while contador < fin:
+        salida.append(contador)
+        contador = contador + 1
+    return salida
+```
+
+Lo que va a ocurrir al llamar a la función, por ejemplo, con esta llamada:
+`range(1, 10)` es que el argumento `inicio` tomará el valor `1` para esta
+ejecución y el argumento `fin` tomará el valor `10`, como si en el propio
+cuerpo de la función alguien hubiese hecho:
+
+``` python
+inicio = 1
+fin    = 10
+```
+
+El contenido de la función se ejecutará, por tanto, con esas referencias
+asignadas a un valor. Con lo que sabes ya puedes intentar descifrar el
+comportamiento de la función `range` que hemos definido, que es similar, pero
+no igual, a la que define python.
+
+Sólo necesitas entender lo que hace la función `list.append` que puedes
+comprobar en la ayuda haciendo `help( list.append )` y la sentencia `return`,
+que se explica en el siguiente apartado.
+
+Prueba a leer ambas y a crear un archivo de python donde construyes la función
+y le lanzas unas llamadas. A ver si lo entiendes.
 
 ### Sentencias útiles
 
@@ -436,3 +507,41 @@ indicado en el `return`. Esta operación rompe todos los bucles por completo.
 En el apartado de las funciones profundizaremos en el uso del `return` pero es
 importante mencionarlo aquí porque su funcionalidad puede sustituir al `break`
 en muchas ocasiones.
+
+## Lo que has aprendido
+
+Es difícil resumir todo lo que has aprendido en este capítulo porque, la verdad
+es que es mucha información. Pero no pasa nada porque este capítulo se ha
+creado más como referencia que como otra cosa. No tengas miedo en volver a
+leerlo todas las veces que necesites. A todos se nos olvida cómo hay que
+declarar las funciones si llevamos mucho tiempo sin tocar python, o si era
+`try-catch` o `try-except`. Este capítulo pretende, por un lado, darte una
+pincelada de cómo se escribe en python y, por otro, servir como manual de
+consulta posterior.
+
+Pero, por hacer la labor de resumen, has aprendido el orden de ejecución de las
+órdenes y como alterarlo con bucles y condicionales. Para ello, has tenido que
+aprender lo que es un *bloque* de código, una pieza fundamental para entender
+la sintaxis. Tras ver varios ejemplos de bucles y condicionales, te has
+sumergido en la verdad y la mentira mediante los valores *truthy* y *falsey*,
+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.
+
+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
+toca jugar con funciones hasta entenderlas por completo.
+
+Las sentencias útiles que hemos recopilado al final permiten juguetear con
+todas las estructuras que hemos definido en el capítulo de modo que puedas
+usarlas a tu antojo de forma cómoda. Algunas de ellas como `continue` y `break`
+no son realmente necesarias, puede programarse evitándolas y, de hecho, en
+algunos lugares enseñan a no usarlas como si de una buena práctica se tratara
+cambiando las condiciones de los bucles para que hagan esta labor. En este
+documento se muestran porque, en primer lugar, si lees código escrito por otras
+personas las encontrarás y tendrás que entender qué hacen y, en segundo, porque
+son sentencias que simplifican el código haciéndolo más legible o más sencillo
+por muy impuras que a algunos programadores les puedan parecer.