Algunas de las funciones internas que hemos usado precisan de argumentos, los valores que controlan como la función lleva a cabo su tarea.

Por ejemplo, si desea encontrar el seno de un numero, tiene que indicar de que numero se trata. Así pues, sin toma como argumento un valor numérico.

Algunas funciones toman mas de un argumento, como pow, que toma dos argumentos: la base y el exponente. Dentro de la función, los valores que se le han pasado se asignan a variables llamadas parámetros.

He aquí un ejemplo de una función definida por el usuario, que toma un parámetro:

   1: def imprimeDoble(paso):

   2: print paso, paso

Esta funcion toma un unico argumento y se lo asigna a un parametro llamado paso. El valor del parametro (en este punto todavía no tenemos ni idea de cual será) se imprime dos veces, seguido por un caracter de nueva línea. El nombre paso se eligio para sugerir que el nombre que le de a un parametro depende de usted, pero en general es mejor que elija un nombre mas ilustrativo que paso.

La funcion imprimeDoble sirve con cualquier tipo (de dato) que se pueda imprimir:

   1: >>> imprimeDoble('Jamon')

   2: Jamon Jamon

   3: >>> 

   4: imprimeDoble(5)

   5: 5 5

   6: >>> imprimeDoble(3.14159)

   7: 3.14159 

   8: 3.14159

En la primera llamada a la funcion, el argumento es una cadena; en la segunda es un entero, y en la tercera es un numero de coma °otante.

Las mismas reglas de composicion que se aplican a las funciones internas se aplican tambien a las funciones definidas por el usuario, así que puede usar cualquier tipo de expresion como argumento de imprimeDoble.

   1: >>> imprimeDoble('Jamon'*4)

   2: JamonJamonJamonJamon 

   3: JamonJamonJamonJamon

   4: >>> imprimeDoble(math.cos(math.pi))

   5: -1.0 

   6: -1.0

Como de costumbre, se evalua la expresion antes de ejecutar la funcion, de modo que imprimeDoble devuelve JamonJamonJamonJamon JamonJamonJamonJamon en lugar de ‘Jamon’*4’Jamon’*4.

Asimismo podemos usar una variable como argumento:

   1: >>> latoya = 'Dafne, es mitad laurel mitad ninfa'

   2: >>> 

   3: imprimeDoble(latoya)

   4: Dafne, es mitad laurel mitad ninfa. Dafne, es mitad 

   5: laurel mitad ninfa.

Observe un aspecto realmente importante en este caso: el nombre de la variable que pasamos como argumento (latoya) no tiene nada que ver con el nombre del parámetro (paso). No importa como se llamaba el valor en su lugar original (el lugar desde donde se invoco); aquí en imprimeDoble llamamos a todo el mundo paso.

Cuando crea una variable dentro de una función, solo existe dentro de dicha función, y no puede usarla fuera de ella. Por ejemplo, la función

   1: >>> def catDoble(parte1, parte2):

   2: ... cat = parte1 + parte2

   3: ... 

   4: imprimeDoble(cat)

   5: ...

   6: >>>

toma dos argumentos, los concatena y luego imprime el resultado dos veces.

Podemos llamar a la funcion con dos cadenas:

   1: >>> cantus1 = "Die Jesu domine, "

   2: >>> cantus2 = "Dona eis 

   3: requiem."

   4: >>> catDoble(cantus1, cantus2)

   5: Die Jesu domine, Dona 

   6: eis requiem. Die Jesu domine, Dona eis requiem.

Cuando catDoble termina, la variable cat se destruye. Si tratasemos de imprimirla, obtendríamos un error:

   1: >>> print cat

   2: NameError: cat

Los parametros tambien son locales. Por ejemplo, una vez fuera de la función imprimeDoble, no existe nada llamado paso. Si trata de usarla, Python se quejara.

Para mantener el rastro de que variables pueden usarse y donde, a veces es útil dibujar un diagrama de pila. Como los diagramas de estado, los diagramas de pila muestran el valor de cada variable, pero también muestran la función a la que cada variable pertenece.

Cada función se representa por una caja con el nombre de la función junto a el. Los parámetros y variables que pertenecen a una función van dentro. Por ejemplo, el diagrama de stack para el programa anterior tiene este aspecto:

El orden de la pila muestra el flujo de ejecución. imprimeDoble fue llamado por catDoble y a catDoble lo invoco __main__ , que es un nombre especial de la función mas alta. Cuando crea una variable fuera de cualquier función, pertenece a main

En cada caso, el parámetro se refiere al mismo valor que el argumento correspondiente. Así que parte1 en catDoble tiene el mismo valor que cantus1 en main .

Si sucede un error durante la llamada a una función, Python imprime el nombre de la función y el nombre de la función que la llamo, y el nombre de la función que llamo a esa, y así hasta main .

Por ejemplo, si intentamos acceder a cat desde imprimeDoble, provocaremos un NameError:

   1: Traceback (innermost last):

   2: File "test.py", line 13, in 

   3: __main__

   4: catDoble(cantus1, cantus2)

   5: File "test.py", line 5, in 

   6: catDoble

   7: imprimeDoble(cat)

   8: File "test.py", line 9, in 

   9: imprimeDoble

  10: print cat

  11: NameError: cat

Esta lista de funciones de llama traceback (traza inversa). Le dice a usted en que archivo de programa sucedió el error, y en que línea, y que funciones se ejecutaban en ese momento. También muestra la línea de código que causo el error.

F³jese en la similaridad entre la traza inversa y el diagrama de pila. No es una coincidencia.

Seguramente ha notado ya que algunas de las funciones que estamos usando, igual que las funciones matemáticas, devuelven un resultado.

Otras funciones, como nueva línea, llevan a cabo una acción pero no devuelven un valor. Ello suscita varias preguntas:

1. ¿Que sucede si llama usted a una función y no hace nada con el resultado (es decir, no lo asigna a una variable ni lo usa como parte de una expresión mas amplia)?

2. ¿Que sucede si usa una función sin resultado como parte de una expresión, por ejemplo nueva línea() + 7?

3. ¿Se pueden escribir funciones que devuelvan resultados, o debemos limitarnos a funciones simples como nueva línea e imprimeDoble?

La respuesta a la tercera pregunta es “sí, puede escribir funciones que devuelvan valores”, y lo haremos en el capítulo 5.

Como actividad final, constaste a las otras dos preguntas intentando hacerlas en la practica. Cada vez que tenga una duda sobre lo que es legal o ilegal en Python, preguntar al interprete será una buena manera de averiguarlo.

llamada a función: Una sentencia que ejecuta una función. Esta compuesta por el nombre de la función mas una lista de argumentos encerrados entre paréntesis.

argumento: Valor que se le pasa a una función cuando se la llama. El valor se asigna al parámetro correspondiente de la función.

valor de retorno: Es el resultado de una función. Si se usa una llamada a función a modo de expresión, el valor de retorno es el valor de la expresión.

conversión de tipo: Una sentencia explícita que toma un valor de un tipo y calcula el valor correspondiente de otro tipo.

coerción: Conversión tipos que ocurre automáticamente de acuerdo con las reglas de coerción de Python.

módulo: Fichero que contiene una colección de funciones y clases relacionadas.

notación de punto: La sintaxis para llamar a una función de otro modulo, especificando el nombre del modulo, seguido por un punto y el nombre de la función.

función: Secuencia de sentencias etiquetadas que llevan a cabo determinada operación de utilidad. Las funciones pueden tomar parámetros o no, y pueden producir un resultado o no.

definición de función: Sentencia que crea una nueva función, especificando su nombre, parámetros y las sentencias que ejecuta.

flujo de ejecución: Orden en el que se ejecutan las sentencias durante la ejecución de un programa.

parámetro: Nombre que se usa dentro de una función para referirse a el valor que se le pasa como argumento.

variable local: variable definida dentro de una función. Las variables locales solo pueden usarse dentro de su función.

diagrama de pila: Representación grafica de una pila de funciones, sus variables y los valores a los que se refieren.

traza inversa: (traceback en ingles) Una lista de las funciones en curso de ejecución, presentadas cuando sucede un error en tiempo de ejecución. notación de punto traza inversa

Condicionales y

recursividad

4.1. El operador modulo

El operador modulo funciona con enteros (y expresiones enteras), y devuelve el resto de dividir el primer operando entre el segundo. En Python, el operador de modulo es el signo de tanto por ciento ( %). La sintaxis es la misma de los otros operadores:

   1: >>> cociente = 7 / 3

   2: >>> print 

   3: cociente

   4: 2

   5: >>> resto = 7 % 3

   6: >>> print resto

   7: 1

Así, 7 dividido entre 3 da 2 con 1 de resto.

El operador de modulo resulta ser soprendentemente util. Por ejemplo, puede comprobar si un numero es divisible entre otro: si x % y es cero, entonces x es divisible entre y.

También puede usar el operador modulo para extraer el dígito mas a la derecha de un numero. Por ejemplo, x % 10 devuelve el dígito mas a la derecha de x (en base 10). De forma similar, x % 100 devuelve los dos últimos dígitos.

Una expresión booleana es una expresión que es cierta o falsa. En Python, una expresión que es cierta tiene el valor 1, y una expresión que es falsa tiene el valor 0.

El operador == compara dos valores y entrega una expresión booleana:

   1: >>> 5 == 5

   2: 1

   3: >>> 5 == 6

   4: 0

En la primera sentencia, los dos operandos son iguales, así que la expresion se evalúa como 1 (verdadero); en la segunda sentencia, 5 no es igual a 6, así que obtenemos 0 (falso).

El operador == es uno de los operadores de comparacion; los otros son:

   1: x != y # x no es igual a y

   2: x > y # x es mayor que y

   3: x < y # x es 

   4: menor que y

   5: x >= y # x es mayor o igual que y

   6: x <= y # x es menor o 

   7: igual que y

Aunque probablemente estas operaciones le resulten familiares, los símbolos en Python son diferentes de los matematicos. Un error habitual es utilizar un signo igual sencillo (=) en lugar del doble (==). Recuerde que = es un operador de asignación y == es un operador de comparacion. Ademas, no existen =.

Hay tres operadores lógicos: and, or, y not. La semántica (significado) de estos operadores es similar a sus significados en ingles. Por ejemplo, x >0 and x <10 es verdadero solo si x es mayor que 0 y menor que 10.

n %2 == 0 or n %3 == 0 es verdadero si cualquiera de las condiciones es verdadera, o sea, si el numero es divisible por 2 o por 3.

Finalmente, el operador not niega una expresión booleana, de forma que not(x>y) es cierto si (x >y) es falso, o sea, si x es menor o igual que y.

Hablando estrictamente, los operandos de los operadores lógicos deberían ser expresiones booleanas, pero Python no es muy estricto. Cualquier numero que no sea cero se interpreta como “verdadero“.

   1: >>> x = 5

   2: >>> x and 1

   3: 1

   4: >>> y = 

   5: 0

   6: >>> y and 1

   7: 0

En general, este tipo de cosas no se considera buen estilo. Si quiere comparar un valor con cero, debería hacerlo explícitamente.

Para escribir programas útiles, casi siempre necesitamos la capacidad de comprobar ciertas condiciones y cambiar el comportamiento del programa en consonancia. Las sentencias condicionales nos dan esta capacidad. La forma mas sencilla es la sentencia if:

   1: if x > 0:

   2:     print "x es positivo"

La expresion booleana tras el if se llama condicion. Si es verdadera, entonces la sentencia indentada se ejecuta. Si la condicion no es verdadera, no pasa nada.

Como otras sentencias compuestas, if consta de una cabecera y un bloque de sentencias:

   1: CABECERA:

   2: PRIMERA SENTENCIA

   3: ...

   4: ULITMA SENTENCIA

A veces hay mas de dos posibilidades y necesitamos mas de dos ramas. Una forma de expresar tal computación es un condicional encadenado:

   1: if x < y:

   2: print x, "es menor que", y

   3: elif x > y:

   4: print x, "es 

   5: mayor que", y

   6: else:

   7: print x, "y", y, "son iguales"

elif es una abreviatura de “else if“. De nuevo, solo se ejecutara una rama. No hay límite al numero de sentencias elif, pero solo se permite una sentencia

   1: else (que puede omitirse) y debe ser la ultima rama de la sentencia:

   2:     if 

   3:         eleccion == 'A':

   4:         funcionA()

   5:     elif eleccion == 'B':

   6:         funcionB()

   7:     elif 

   8:         eleccion == 'C':

   9:         funcionC()

  10:     else:

  11:         print "Eleccion no valida."

  12:     

Las condiciones se comprueban en orden. Si la primera es falsa, se comprueba la siguiente, y así. Si una de ellas es cierta, se ejecuta la rama correspondiente y termina la sentencia. Incluso si es cierta mas de una condicion, solo se ejecuta la primera rama verdadera.

Como ejercicio, envuelva estos ejemplos en funciones llamadas compara(x, y) y resuelve(eleccion).