Start with functions

1 files changed, 310 insertions, 0 deletions

diff --git a/src/04_funciones.md b/src/04_funciones.md
new file mode 100644
index 0000000..3e21f97
--- /dev/null
+++ b/src/04_funciones.md
@@ -0,0 +1,310 @@
+# Funciones
+
+El objetivo de este capítulo es que sientas comodidad en el uso de las
+funciones. Parece sencillo pero es una tarea un tanto complicada porque, visto
+como nos gusta hacer las cosas, tenemos una gran cantidad de complejidad que
+abordar.
+
+Antes de entrar, vamos a definir una función y a usarla un par de veces:
+
+``` python
+def inc(a):
+    b = a + 1
+    return b
+```
+
+Si lanzamos:
+
+```
+>>> inc(1)
+2
+>>> inc(10)
+11
+```
+
+Si preguntamos por `b`:
+
+```
+>>> b
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'b' is not defined
+```
+
+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.
+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
+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
+trata en términos de espacio en el programa.
+
+El recolector de basura tiene unas normas muy estrictas y conociéndolas es
+fácil saber en qué espacio se puede mover una referencia sin ser disuelta.
+
+Resumiendo mucho, las referencias que crees se mantienen vivas hasta que la
+función termine. Como en el caso de arriba la función en la que se había creado
+`b` había terminado, `b` había sido limpiada por el recolector de basura. `b`
+era una referencia *local*, asociada a la función `inc`.
+
+Puede haber referencias declaradas fuera de cualquier función, que se llaman
+*globales*. Éstas se mantienen accesibles desde cualquier punto del programa, y
+se mantienen vivas hasta que éste se cierre. Considera que el propio programa
+es una función gigante que engloba todo.
+
+Python define que cualquier declaración está disponible
+en bloques internos, pero no al revés. El siguiente ejemplo lo muestra:
+
+``` python
+c = 100
+def funcion():
+    a = 1
+    # Se conoce c aquí dentro
+# Aquí fuera no se conoce a
+```
+
+El *scope* es peculiar en algunos casos que veremos ahora, pero mientras tengas
+claro que se extiende hacia dentro y no hacia fuera, todo irá bien.
+
+## First-class citizens
+
+Antes de seguir jugando con el *scope*, necesitas saber que las funciones en
+python son lo que se conoce como *first-class citizens* (ciudadanos de primera
+clase). Esto significa que pueden hacer lo mismo que cualquier otro valor.
+
+Las funciones son un valor más del sistema, como puede ser un string, y su
+nombre no es más que una referencia a ellas.
+
+Por esto mismo, pueden ser enviadas como argumento de entrada a otras
+funciones, devueltas con sentencias `return` o incluso ser declaradas dentro de
+otras funciones.
+
+Por ejemplo:
+
+``` python
+>>> def filtra_lista( lista ):
+...     def mayor_que_4(a):
+...         return a > 4
+...     return list( filter(mayor_que_4, lista) )
+... 
+>>> filtra_lista( [1,2,3,4,5,6,7] )
+[5, 6, 7]
+```
+
+En este ejemplo, haciendo uso de la función `filter` (usa la ayuda para ver lo
+que hace), filtramos todos los elementos mayores que `4` de la lista. Pero para
+ello hemos creado una función que sirve para compararlos y se la hemos
+entregado a la función `filter`.
+
+Este ejemplo no tiene más interés que intentar enseñarte que puedes crear
+funciones como cualquier otro valor y asignarles un nombre, para después
+pasarlas como argumento de entrada a otra función.
+
+## Lambdas
+
+Las funciones *lambda*[^lambda] o funciones anónimas son una forma sencilla de
+declarar funciones simples sin tener que escribir tanto. Python las define como
+funciones para vagos.
+
+La sintaxis de una función lambda te la enseño con un ejemplo:
+
+```
+>>> lambda x, y: x+y
+<function <lambda> at 0x7f035b879950>
+>>> (lambda x, y: x+y)(1,2)
+3
+```
+
+En el ejemplo primero se muestra la declaración de una función y después
+colocando los paréntesis de precedencia y después de llamada a función se
+construye una función a la izquierda y se ejecuta con los valores `1` y `2`.
+
+Es fácil de entender la sintaxis de la función lambda, básicamente es una
+función reducida de sólo una sentencia con un `return` implícito.
+
+El ejemplo de la función `filra_lista` puede reducirse mucho usando una función
+lambda:
+
+``` python
+>>> def filtra_lista( lista ):
+...     return list( filter(lambda x: x > 4, lista) )
+... 
+>>> filtra_lista( [1,2,3,4,5,6,7] )
+[5, 6, 7]
+```
+
+No necesitábamos una función con nombre en este caso, porque sólo iba a
+utilizarse esta vez, así que resumimos y reducimos tecleos.
+
+De todos modos, podemos asignarlas a una referencia para poder repetir su uso:
+
+``` python
+>>> f = lambda x: x+1
+>>> f(1)
+2
+>>> f(10)
+11
+>>> f
+<function <lambda> at 0x7f02184febf8>
+```
+
+Las funciones lambda se usan un montón como *closure*, un concepto donde el
+*scope* se trabaja más allá de lo que hemos visto. Sigamos visitando el
+*scope*, para entender sus usos más en detalle.
+
+[^lambda]: Toman su nombre del (Lambda
+  Calculus)[https://en.wikipedia.org/wiki/Deductive_lambda_calculus].
+
+## Scope avanzado
+
+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.
+
+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
+madre pueden encontrarse y accederse y no al revés.
+
+Aunque hemos explicado el *scope* como un concepto asociado a las funciones, la
+realidad es que hay varias estructuras que crean nuevos contextos en python. El
+comportamiento sería el mismo del que se ha hablado anteriormente, las
+referencias que se creen en ellos no se verán en el *scope* de nivel superior,
+pero sí al revés. Los casos son los siguientes:
+
+- Los módulos. Ver capítulo correspondiente
+- Las clases. Ver capítulo de Programación Orientada a Objetos.
+- Las funciones, incluidas las funciones anónimas o lambda.
+- Las expresiones generadoras[^generator-expression], que normalmente se
+  encuentran en las *list-comprehension* que ya se han tratado en el capítulo
+  previo.
+
+[^generator-expression]: <https://www.python.org/dev/peps/pep-0289/>
+
+
+### Global
+
+Hemos hablado de qué sentencias crean nuevos contextos, pero no hemos hablado
+de qué pasa si esos nuevos contextos crean referencias cuyo nombre es idéntico
+al de las referencias globales.
+
+Partiendo de lo que se acaba de explicar, y antes de adentrarnos en ejemplos,
+si se crea una función (o cualquiera de las otras estructuras) python creará un
+contexto para ella. Una vez creado, al crear una variable en este nuevo
+contexto, python añadirá una nueva entrada en su tabla hija con el nombre de la
+variable. Al intentar consultarla, python encontrará que en su tabla hija
+existe la variable y tomará el valor con el que la declaramos. Cuando la
+función termine, la tabla de contexto asociada a la función será eliminada.
+Esto siempre es así, independientemente del nombre de referencia que hayamos
+seleccionado. Por tanto, si el nombre ya existía en alguno de los contextos
+padre, lo ocultaremos, haciendo que dentro de esta función se encuentre el
+nombre recién declarado y no se llegue a buscar más allá. Cuando la función
+termine, como el contexto asociado a ésta no está en la zona de búsqueda de la
+función madre, en la función madre el valor seguirá siendo el que era.
+
+Ilustrándolo en un ejemplo:
+
+```
+>>> a = 1
+>>> def f():
+...     a = 2 
+...     print(a)
+... 
+>>> a
+1
+>>> f()
+2
+```
+
+Aunque el nombre de la referencia declarada en el interior sea el mismo que el
+de una referencia externa su declaración no afecta, lógicamente, al exterior
+ya que ocurre en un contexto independiente.
+
+Para afectar a la referencia externa, python dispone de la sentencia `global`.
+La sentencia `global` afecta al bloque de código actual, indicando que los
+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.
+
+```
+>>> a = 1
+>>> def f():
+...     global a
+...     a = 2 
+...     print(a)
+... 
+>>> f()
+2
+>>> a
+2
+```
+
+> NOTA: Te recomiendo, de todas formas, que no edites valores globales desde
+> el cuerpo de funciones. Es más elegante y comprensible si los efectos de las
+> funciones sólo se aprecian en los argumentos de entrada y salida.
+
+Para más detalles sobre limitaciones y excepciones, puedes buscar en la ayuda
+ejecutando `help("global")`.
+
+### Scope léxico, Closures
+
+Hemos dicho que las funciones pueden declararse dentro de funciones, pero no
+hemos hablado de qué ocurre con el *scope* cuando la función declarada se
+devuelve y tiene una vida más larga que la función en la que se declaró. El
+siguiente ejemplo te pone en contexto:
+
+``` python
+def create_incrementer_function( increment ):
+    def incrementer (val):
+        # Recuerda que esta función puede ver el valor `increment` por
+        # por haber nacido en un contexto superior.
+        return val + increment
+    return incrementer
+
+increment10 = create_incrementer_function( 10 )
+increment( 10 )   # Returns 20
+increment1 = create_incrementer_function( 1 )
+increment( 10 )   # Returns 11
+```
+En este ejemplo hemos creado una función que construye funciones que sirven
+para incrementar valores.
+
+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
+hiciera, las funciones devueltas no funcionarían porque no podrían incrementar
+el valor. Habrían olvidado con qué valor debían incrementarlo.
+
+Para que esto pueda funcionar, las funciones guardan el contexto del momento de
+su creación, así que la función `incrementer` recuerda la primera vez que fue
+construida en un contexto en el que `increment` valía `10` y la nueva
+`incrementer` creada en la segunda ejecución de `create_incrementer_function`
+recuerda que cuando se creó `increment` tomó el valor `1`. Ambas funciones son
+independientes, aunque se llamen de la misma forma en su concepción, no se
+pisaron la una a la otra, porque pertenecían a contextos distintos ya que la
+función que las creaba terminó y luego volvió a iniciarse.
+
+
+## Argumentos de entrada
+
+### Positional and Keyword Arguments
+
+#### Defaults
+
+> WARNING! MUTABLE DEFAULTS 
+
+## Decorators