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).

Una condición puede estar anidada dentro de otra. Podíamos haber escrito así el ejemplo de tricotomía:

   1: if x == y:

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

   3: else:

   4:     if x < y:

   5:         print 

   6:         x, "es menor que", y

   7:     else:

   8:         print x, "es mayor que", y

La condicion externa que contiene dos ramas. La primera rama contiene una sentencia simple de salida. La segunda rama contiene otra sentencia if, que tiene dos ramas en sí misma. Estas dos ramas son ambas sentencias de salida de datos, aunque podrían ser igualmente sentencias condicionales.

Aunque la indentacion de las sentencias hace la estructura evidente, las condiciones anidadas en seguida se vuelven difíciles de leer. En general es una buena idea evitarlas cuando pueda.

Los operadores logicos suelen facilitar un modo de simplificar las sentencias condicionales anidadas. Por ejemplo, podemos reescribir el codigo siguiente con un solo condicional:

   1: if 0 < x:

   2:     if x < 10:

   3:         print "x es un numero positivo de un dígito."

La sentencia print solo se ejecuta si conseguimos superar ambos condicionales, así que podemos usar el operador and:

La sentencia return le permite terminar la ejecución de una función antes de alcanzar su final. Una razón para usarla es detectar una condición de error:

   1: import math

   2:     def imprimeLogaritmo(x):

   3:         if x <= 0:

   4:             print "Solo numeros positivos, por favor."

   5:             return 

   6:         result = math.log(x)

   7:         print "El log de x es", result

La funcion imprimeLogaritmo toma un parametro llamado x. Lo primero que hace es comprobar si x es menor o igual que cero, en cuyo caso muestra un mensaje de error y luego usa return para salir de la funcion. El flujo de la ejecución vuelve inmediatamente al llamante y no se ejecutan las líneas restantes de la funcion.

Recuerde que para usar una funcion del modulo math tiene que importarlo.