Python: Funciones para ricos y funciones para pobres

Objetivo: mostrar que las funciones son objetos e ilustrar su uso como argumentos de otras funciones.

Lo hemos dicho ya en alguna que otra ocasión: en Python todo son objetos. Incluso una función es un objeto.

Obsérvalo:

>>> def saluda(nombre):
  print('Hola', nombre)

>>> saluda('Javier')
Hola Javier

>>> type(saluda)
<class 'function'>
>>> print(saluda)
<function saluda at 0x02500078>

Esta circunstancia nos permite ciertos usos que pueden parecer estrambóticos a simple vista. Si una función es un objeto, tiene derecho a que se le trate como tal, bajo riesgo de protestar por agravio comparativo.

Entre otras cosas, tiene derecho a que se use su nombre en asignaciones:

>>> bienvenida = saluda

De modo que ya podemos realizar invocaciones como:

>>> bienvenida('Pedro')
Hola Pedro

Ambos nombres, saluda y bienvenida, referencian al mismo objeto función:

>>> id(bienvenida)
38797432
>>> id(saluda)
38797432

El nombre de una función también puede ser pasado como argumento de otra función.

Vamos a ilustrarlo con un ejemplo muy sencillo. Imagínate que tenemos dos funciones de tarificación diferentes por un mismo servicio. A los clientes normales les aplicaremos un rasero, pero a los más pudientes les daremos una pequeña clavada y su factura será mayor.

def tarifar(horas):
    importe = horas * 20 # Cobramos 20 euros la hora
    return importe

def tarifarplus(horas):
    importe = horas * 60 # Cobramos 60 euros la hora
    return importe

La función tarifar() toma como argumento el número de horas trabajadas y devuelve el importe correspondiente a una tasa de 20 euros la hora. La función tarifarplus() tiene como diferencia el pequeño detalle de que el precio por hora es mayor.

Observa ahora la definición de esta otra función:

def facturar(funcion_tarificacion, horas):
    return funcion_tarificacion(horas)

Como argumentos le pasaremos, además de las horas empleadas, el nombre de la función con la que realizaremos la facturación, función que será empleada para devolver el importe final.

Veamos un ejemplo de invocación de la función facturar() en un intérprete interactivo:

Si tienes poco dinero:

>>> facturar(tarifar, 5)
100

Pero, si te sobra la pasta, te mereces pagar más:

>>> facturar(tarifarplus, 5)
300

Justicia social.

Javier Montero Gabarró


Python: Funciones para ricos y funciones para pobres


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

LaTeX – Capítulo 30: Límites de funciones y sucesiones

Objetivo: aprender los rudimentos para la escritura en \LaTeX de fórmulas matemáticas relacionadas con los límites de funciones y sucesiones.

Observa el siguiente límite de una función de una variable:

¿Cómo generamos esa salida en \LaTeX?

Existen elementos desconocidos hasta ahora: ¿cómo hacemos para que aparezca el “x tiende a 5” debajo de lim? ¿Cómo dibujamos la flecha del “tiende a”?

El comando en \LaTeX para escribir límites es \lim. Lo que figura en la parte inferior se indica empleando la notación de subíndices. Ya te avisé de que emplearíamos los subíndices y superíndices para otros usos aparte del obvio. La notación de límites es un ejemplo de esa multifuncionalidad.

Finalmente, para escribir la flecha del “tiende a” recurrimos a otro comando de \LaTeX: \to.

Ya podemos componer la fórmula:

\[
\lim_{x \to 5}(x+3)=8
\]

Vamos a complicarlo un poquito más. Considera el límite de la siguiente sucesión:

Salvo por los símbolos de infinito, el resto ya es pan comido.

Como siempre, \LaTeX tiene un comando para todo. La escritura del símbolo de infinito se genera con \infty:

\[
\lim_{n \to \infty}(n^{2}+n+1)=+\infty
\]

Y ahora la prueba de fuego: ¿serías capaz de generar en \LaTeX la definición del número e?

Si lo consigues es señal de que vas al día con los artículos publicados hasta ahora, pues además de lo explicado hoy se manejan conceptos como la potenciación, las fracciones, o el uso de paréntesis que adaptan su tamaño a la expresión que contienen.

Solución:

\[
e=\lim_{n \to \infty}\left(1+\frac{1}{n}\right)^{n}
\]

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/06/latex-capitulo-30-limites-de-funciones-y-sucesiones/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos relacionados con \LaTeX.

Python – Capítulo 32: Funciones que devuelven varios valores

Python es un lenguaje, cuanto menos, curioso. Acostumbrado a otros lenguajes de programación, estudiar Python ha sido algo que nunca ha estado exento de artificiosas sorpresas. Estoy seguro de que muchos lo adoramos por esa originalidad, esa personalidad propia que lo hace tan especial.

Recuerdo, por ejemplo, cuando me encontré por primera vez con esta sorprendente sentencia:

x,y = y,x

Esta simple línea intercambia los valores de las variables x e y sin necesidad de recurrir a una tercera variable temporal. Reconozco que me dejó un poco descuadrado.

Verifícalo,

>>> x=1
>>> y=2
>>> x,y=y,x
>>> x
2
>>> y
1

O cuando me encontré con una función que devolvía varios valores…

Por ejemplo, diseñemos una función que tome dos argumentos y calcule el cociente y el resto de la división entera del primero entre el segundo:

>>> def desguazar(dividendo, divisor):
  cociente = dividendo//divisor
  resto = dividendo%divisor
  return cociente,resto

Observa como utilizo el operador // para el cociente de la división entera y % para el cálculo del resto.

cociente = dividendo//divisor
resto = dividendo%divisor

Hasta ahí bien, pero la línea en que devuelvo el resultado al exterior parece desafiar a toda lógica:

return cociente,resto

¿Qué es esto, una función que devuelve dos valores? ¿Cómo utilizo esto en el exterior?

Mira qué sencillo:

>>> x,y = desguazar(14,4)
>>> x
3
>>> y
2

Sorprendente.

No fue hasta que me presentaron las tuplas cuando ese misterio comenzó a desentrañarse.

Una función, propiamente hablando, sólo puede devolver un objeto, pero ese objeto puede estar compuesto de otros objetos más simples. Las listas o las tuplas son ejemplos de objetos compuestos.

¿Recuerdas cuando dijimos que la forma de definir una tupla era simplemente separar cada valor entre comas? En el artículo comentamos también que el uso de paréntesis era opcional y sólo era forzosamente exigido en caso de que la construcción se prestara a confusión.

Cuando hacemos algo como

return cociente,resto

lo que estamos haciendo, en realidad, es empaquetar las variables cociente y resto en una tupla. Quizás no habría tenido un efecto visual tan sorprendente si lo hubiéramos escrito así:

return (cociente,resto)

Es exactamente lo mismo, pero ahora resulta más evidente que se trata de una tupla.

Ahora si podemos comprender esto claramente ya:

>>> x,y = desguazar(14,4)
>>> x
3
>>> y
2

La función desguazar nos devuelve una tupla que asignamos a otra tupla, la formada por las variables x e y separadas entre comas (que ya sabes que podríamos haber rodeado entre paréntesis). Observa ahora el fenómemo contrario de desempaquetado.

Si eres un escéptico y no te crees que lo que devuelve return sea una tupla, prueba a ejecutar la función en IDLE:

>>> desguazar(17,3)
(5, 2)

Es una tupla: observa como IDLE muestra la salida de una tupla empleando paréntesis, aunque sean opcionales en su creación.

El empaquetado y desempaquetado de secuencias es sólo uno de los artificios mágicos que tiene Python, pero aún hay muchos más. ¿Te animas a descubrirlos?

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/04/python-capitulo-32-funciones-que-devuelven-varios-valores/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Python – Capítulo 27: Funciones con argumentos por defecto

Continuando con el tema de las funciones en Python, voy a mostrarte hoy una técnica interesante que permite facilitar argumentos por defecto a una función. Veamos qué significa esto.

En capítulos anteriores vimos el uso de argumentos en las funciones. Recuerda la función praderazo(), que mostraba un texto detérminado repetidas veces y enmarcado por un símbolo a elegir.

Su definición era la siguiente:

def praderazo(veces,simbolo):
    print(simbolo*42)
    for n in range(veces):
      print(simbolo,'La casa de la pradera, pedazo serie...',simbolo)
    print(simbolo*42)

veces y simbolo son los argumentos de la función. Ejemplos de invocación posibles podrían ser:

>>>praderazo(5,'+')

o

>>>praderazo(100,'&')

La función, para ser invocada correctamente, necesita forzosamente dos argumentos. Decimos que veces y simbolo son argumentos requeridos.

Esta llamada generaría un error, como podemos comprobar:

>>> praderazo(5)
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    praderazo(5)
TypeError: praderazo() takes exactly 2 arguments (1 given)

Lo que nos dice el mensaje de error es que praderazo() requiere exactamente dos argumentos y sólo uno ha sido facilitado.

Observa ahora esta nueva definición de praderazo():

def praderazo(veces,simbolo='+'):
    print(simbolo*42)
    for n in range(veces):
      print(simbolo,'La casa de la pradera, pedazo serie...',simbolo)
    print(simbolo*42)

Fíjate en como está descrito el argumento simbolo, especificando directamente un valor.

Decimos que simbolo es un argumento por defecto y el valor especificado es el valor que tomará por defecto en caso de que no se facilite uno concreto.

Ya no es necesario especificar el segundo argumento, si no queremos. En caso de que no lo hagamos, simbolo tomará el valor por defecto (el signo ‘+’).

>>> praderazo(5)
++++++++++++++++++++++++++++++++++++++++++
+ La casa de la pradera, pedazo serie... +
+ La casa de la pradera, pedazo serie... +
+ La casa de la pradera, pedazo serie... +
+ La casa de la pradera, pedazo serie... +
+ La casa de la pradera, pedazo serie... +
++++++++++++++++++++++++++++++++++++++++++

Si no queremos usar el valor por defecto, hay que recurrir a la especificación completa:

>>> praderazo(3,'%')
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% La casa de la pradera, pedazo serie... %
% La casa de la pradera, pedazo serie... %
% La casa de la pradera, pedazo serie... %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Es importante tener en cuenta que los argumentos por defecto deben figurar siempre después de los requeridos, y nunca antes. Supongamos que hubiéramos querido dejar por defecto veces y requerido simbolo:

>>> def praderazo(veces=5,simbolo):
    print(simbolo*42)
    for n in range(veces):
      print(simbolo,'La casa de la pradera, pedazo serie...',simbolo)
    print(simbolo*42)
    
SyntaxError: non-default argument follows default argument

Obtendríamos un error sintáctico reflejando que hay argumentos que no son por defecto después de los que sí lo son. Si no fuera así Python podría liarse a la hora de saber qué argumentos son unos u otros.

La definición correcta habría sido:

>>> def praderazo(simbolo,veces=5):
    print(simbolo*42)
    for n in range(veces):
      print(simbolo,'La casa de la pradera, pedazo serie...',simbolo)
    print(simbolo*42)

Veamos un nuevo ejemplo:

>>> def mifuncion(a,b=2,c=3):
  print(a+b+c)

Toma tres parámetros y calcula la suma de ellos. Si no especificamos ni b ni c tomará sus valores por defecto.

Invoquemos a la función de diversas maneras:

>>> mifuncion(4,5,6)
15

>>> mifuncion(6,4)
13

En este segundo ejemplo, los dos primeros argumentos corresponden a a y a b. Como no hemos especificado c, toma su valor por defecto.

>>> mifuncion(5)
10

Aquí hemos indicado sólo a, el único que es requerido. Los demás argumentos toman sus valores por defecto.

Para concluir, te propongo un ejercicio: adapta la función praderazo() para que el texto a enmarcar sea elegible por el usuario como argumento.

Pista: recuerda la función len(), que determina la longitud de una cadena.

Javier Montero


Python – Capítulo 27: Funciones con argumentos por defecto


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Python – Capítulo 26: Funciones que devuelven valores

En entregas anteriores explicamos el concepto de función y diseñamos algunos ejemplos sencillos. Vimos cómo utilizar una función para realizar una determinada tarea que presumiblemente volvería a repetirse, permitiéndonos así la reutilización del mismo código dentro del programa. También ilustramos el paso de argumentos, aquellos datos que facilitábamos a la función y que luego serían procesados dentro de su cuerpo.

Todos los ejemplos compartían algo en común: realizaban una tarea concreta (presentar información en pantalla), pero no devolvían ningún valor al ser invocadas.

Ya conoces algunas funciones en Python que devuelven valores. Por ejemplo, recuerda la función int(), que convertía una cadena de caracteres en un número entero, o la función len(), que devolvía la longitud de una cadena.

Los valores que devuelven las funciones pueden ser capturados y esto típicamente se hace asignando una variable, pudiendo formar parte de una expresión numérica.

longitud = len('La casa de la pradera')

Esta instrucción asignaría el valor numérico 21 a la variable longitud.

Los valores que devuelven las funciones no tienen que ser necesariamente numéricos.

Voy a mostrarte cómo hacer para que una función devuelva un valor. Crearemos una que admita como argumento un número natural y que devuelva la suma de todos los naturales que hay hasta él inclusive. Es decir, si, por ejemplo, le facilitamos como argumento un 5, nos devuelva la suma:

1 + 2 + 3 + 4 + 5 = 15

Podríamos hacer un algoritmo para realizar el cálculo empleando un bucle, pero no va ser necesario. Si recordáis las enseñanzas en la escuela, hay una fórmula directa para calcular la suma de todos los términos de una progresión aritmética de diferencia uno:

sp=\frac{n(n+1)}{2}

Ya estamos en condiciones de crear nuestra función:

Abre IDLE o el intérprete interactivo y escribe el siguiente código:

>>> def sumaprogresion(n):
       sp=n*(n+1)//2
       return sp

La función toma como argumento un valor que almacena en la variable n. Este valor es utilizado para el cálculo de la suma, almacenando el resultado en la variable sp.

Fíjate en la instrucción

return sp

Esta línea es la que indica qué valor devolverá la función. En este ejemplo, lo que contenga la variable sp, que es la que almacena el resultado del cálculo de la suma de la progresión.

Para realizar el cálculo he empleado la división entera (//), en vez de la ordinaria (/). Así evito que se escriba el resultado con un punto decimal.

Probémoslo:

>>> sumaprogresion(5)
15

Recuerda que esto es equivalente a hacer

>>>print(sumaprogresion(5))

En el intérprete interactivo te puedes ahorrar el print, pero no así cuando escribas un programa fuera de él.

Veamos otro ejemplo:

>>> print('La suma de los 1000 primeros números naturales es', sumaprogresion(1000))
La suma de los 1000 primeros números naturales es 500500

Así de simple.

Javier Montero


http://elclubdelautodidacta.es/wp/2011/12/python-capitulo-26-funciones-que-devuelven-valores/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Python – Capítulo 25: Pasando argumentos a las funciones

En el capítulo anterior nos aproximamos al mundo de las funciones y comenzamos por el ejemplo más básico: una función sin argumentos que se limitaba a ejecutar un conjunto de instrucciones.

En el artículo de hoy aprenderemos a facilitar argumentos, que serán utilizados como variables dentro del cuerpo de la función.

Vayamos con el primer ejemplo básico. Arranca el intérprete interactivo y prepárate a introducir algo de código. Me gusta el intérprete interactivo para ilustrar los conceptos simples, sin necesidad de desarrollar un programa completo. Esa es la metodología de esta serie de artículos: los conceptos se explican en el contexto más simple posible. Esa “molecularidad” de la información facilita el aprendizaje. En capítulos posteriores trabajaremos con programas completos y algoritmos que requerirán el despliegue de muchas de estas piezas que ahora aprendemos de forma individual.

Introduce en el intérprete interactivo las dos líneas siguientes:

>>> def megustapython(veces):
  print('Aprender a programar en Python es divertidísimo\n'*veces)

Fíjate cómo, después de introducir la primera y pulsar Enter, automáticamente el cursor aparece indentado, preparado para la introducción del bloque de instrucciones.

Una vez incluida la segunda línea, pulsa Enter dos veces para finalizar la edición de la función y regresar al prompt.

¿Qué hace esta función?

Va a imprimir la línea Aprender a programar en Python es divertidísimo tantas veces como indique la variable veces que facilitamos como argumento.

Observa como el argumento se incluye dentro de los paréntesis en la primera línea de la definición de la función.

El código de impresión no debe suponerte ningún misterio. He vuelto a usar el truco que vimos en el capítulo anterior: multiplicar una cadena de caracteres por un número entero hace que la cadena se repita ese número de veces. Al final del string (usaré indistintamente este término o “cadena de caracteres”) he incluido el carácter de escape \n, que ya sabes que introduce un salto de línea.

Vamos a invocar a la función. Por ejemplo:

>>> megustapython(5)
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo
Aprender a programar en Python es divertidísimo

En esta invocación, la variable veces toma el valor 5. Como resultado, la línea de texto se “multiplica” por 5 y aparece 5 veces en la pantalla.

Las funciones pueden admitir más de un argumento y de cualquier tipo, no sólo numérico.

Volvamos a la función praderazo() del capítulo anterior:

def praderazo():
    print('+'*42)
    print('+ La casa de la pradera, pedazo serie... +')
    print('+'*42)

Esta función imprime el texto La casa de la pradera, pedazo de serie…, enmarcado con símbolos de suma.

Vamos a modificarlo para que repita esa frase tantas veces como deseemos y, además, para que podamos elegir el símbolo que emplearemos como marco.

Facilitaremos dos argumentos a la función: veces y simbolo, que contendrán, como su nombre indica, el número de veces a repetir y el símbolo utilizado en el marco.

def praderazo(veces,simbolo):
    print(simbolo*42)
    for n in range(veces):
      print(simbolo,'La casa de la pradera, pedazo serie...',simbolo)
    print(simbolo*42)

Voy a explicar algunas particularidades del código:

La primera línea del cuerpo debe estar clara: imprime 42 veces el símbolo facilitado como parámetro.

Comenzamos a continuación un bucle for que se repetirá tantas veces como hemos indicado en la variable veces. Si no recuerdas el uso de la función range(), puedes revisar el capítulo 20.

En la línea del print se escribe el símbolo, contenido en la variable del mismo nombre que hemos facilitado como argumento, seguido de la frase y cerrando nuevamente con el símbolo. Cuando concatenamos las cadenas separándolas entre comas en print(), Python inserta automáticamente un espacio en blanco entre ellas.

Cerramos el marco, finalmente, imprimiendo nuevamente 42 veces el símbolo.

Invoquemos al genio de la lámpara:

>>>praderazo(5,'?')
??????????????????????????????????????????
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
? La casa de la pradera, pedazo serie... ?
??????????????????????????????????????????

Son ejemplos muy básicos, pero seguro que ya intuyes la tremenda potencia de las funciones…

Javier Montero


Python – Capítulo 25: Pasando argumentos a las funciones


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Python – Capítulo 24: Introducción a las funciones

Ha llegado el momento de dar una primera capa a las funciones, concepto clave sobre el que se asienta la modularidad de cualquier lenguaje de programación.

Las funciones nos permiten reutilizar código. Por ejemplo, suponte que tienes que calcular la media aritmética de un conjunto de números. Ya sabes que la media es igual a lo que suman estos números dividido entre el total de estos.

Podrías escribir una expresión numérica que realizase este cálculo. Es posible, incluso, que tuvieras que gestionar un bucle si no conoces de antemano el número de elementos.

En cualquier caso, es un problema sencillo. Pero, ¿y si tuvieras que realizar la operación más veces con diversos conjuntos de números? ¿Volverías a copiar y pegar todo el código cada vez que necesitaras repetir el cálculo?

Gracias a las funciones es suficiente con que escribas el código una única vez. Cada vez que necesites calcular tu media aritmética bastará con que invoques a la función facilitándole, en cada ocasión, como argumentos, el conjunto de números sobre el que efectuarás la operación.

Python trae consigo una biblioteca repleta de funciones predefinidas que ya están inmediatamente a tu disposición. Ya conoces algunas de ellas.

Por ejemplo, la función print() toma como argumento una cadena de texto y realiza una tarea muy concreta: mostrarla en pantalla.

>>> print('Esta es la función print')
Esta es la función print

¿Y qué me dices de la función len(), que nos devolvía la longitud de una cadena de texto?

Fíjate en que he empleado el verbo devolver. La función len() es un ejemplo de función que nos devuelve un valor numérico. Como devuelve un valor, la función puede formar parte de una expresión numérica:

>>> longitud = len('Devuelve la longitud de esta cadena')
>>> longitud
35

A lo largo de esta serie de artículos te mostraré muchas funciones de la biblioteca de Python con las que irás aumentando tu repertorio de recursos, pero ahora de lo que se trata es que aprendas a crear las tuyas propias.

Y vamos a empezar por lo más básico: una simple función que realice una acción determinada. No admitirá parámetros ni devolverá valor alguno; simplemente realizará una acción concreta.

Veamos su definición en el siguiente fragmento de código:

def praderazo():
    print('+'*42)
    print('+ La casa de la pradera, pedazo serie... +')
    print('+'*42)

Lo primero que debes observar es que para definir una función empleamos la palabra reservada def. No podría ser otra, claro…

A continuación de def figura el nombre que le damos a la función. Los distintos argumentos que aceptaría se incluirían entre los paréntesis. En el ejemplo, la función praderazo() no acepta argumentos, por lo que los paréntesis están vaciós (pero deben figurar, aunque no contengan nada).

Tras los paréntesis tenemos los dos puntos que ya hemos visto en las estructuras de control if, while y for. Nos indican que lo que viene a continuación es el cuerpo de la función, su contenido propiamente dicho.

Todo el bloque de instrucciones que la función ejecuta aparece indentado. Como ya sabes, esta es la forma en la que Python reconoce que es un bloque y sabe dónde termina.

La función praderazo() ejecuta tres sentencias. La primera la he puesto para ilustrar una técnica curiosa de Python:

print('+'*42) provoca que se imprima en pantalla 42 veces el símbolo +. Observa qué uso tan interesante.

Es importante entender que el código de la función aún no produciría ninguna salida. Para que esto suceda, hay que invocarla, como si del genio de la lámpara se tratara.

La invoco con su nombre (y los argumentos si los hubiera, pero aquí no es el caso):

praderazo()

Esto provocaría la siguiente salida en pantalla:

++++++++++++++++++++++++++++++++++++++++++
+ La casa de la pradera, pedazo serie... +
++++++++++++++++++++++++++++++++++++++++++

Una regla importante de Python es que el código de definición de la función debe preceder al de la invocación. Es decir, nunca llames a una función que no haya sido definida previamente.

Ahora, en el programa, podrás invocar a la función cuantas veces desees. Cada vez que lo hagas se producirá la misma salida.

Quédate con esto por hoy. Ya sabes lo que es una función y este ejemplo te ha permitido conocer su sintaxis básica. En las próximas entregas seguiremos abundando en esto y empezaremos a jugar con argumentos.

praderazo()

++++++++++++++++++++++++++++++++++++++++++
+ La casa de la pradera, pedazo serie... +
++++++++++++++++++++++++++++++++++++++++++

Javier Montero


http://elclubdelautodidacta.es/wp/2011/11/python-capitulo-24-introduccion-a-las-funciones/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta