Categoría: Sin categoría Página 34 de 51

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.

Ya mencionamos que es legal que una función llame a otra, y de ello hemos visto ya varios ejemplos. Olvidamos mencionar que también es legal que una función se llame a sí misma. Puede no resultar evidente por que es bueno esto, pero viene a resultar una de las cosas mas interesantes y curiosas que puede hacer un programa. Examine por ejemplo la siguiente función:

   1: def cuenta_atras(n):

   2:     if n == 0:

   3:         print "Despegando!"

   4:     else:

   5:         print  n cuenta_atras(n-1)

   6:     

cuenta atras espera que su parametro, n, sea un entero positivo. Si n el parámetro es cero, muestra la palabra “¡Despegando!”. En otro caso, muestra n y luego llama a la funcion llamada cuenta atras (ella misma) pasandole como argumento n-1.

¿Que sucede si llamamos a la funcion de la siguiente manera?

   1: >>> cuenta_atras(3)

La ejecucion de cuenta atras comienza con n=3, y puesto que n no es cero, da como salida el valor 3, y luego se llama a sí misma …

La ejecucion de cuenta atras comienza con n=2, y puesto que n no es cero, muestra el valor 2 y luego se llama a sí misma …

La ejecucion de cuenta atras comienza con n=1, y puesto que n no es cero, muestra el valor 1, y luego se llama a
sí misma…

La ejecucion de cuenta atras comienza con n=0, y puesto que n es cero, muestra la palabra Despegando!” y luego retorna.

La cuenta atras que dio n=1 retorna.

La cuenta atras que dio n=2 retorna.

La cuenta atras que dio n=3 retorna.

Y entonces ya esta de vuelta en main (menudo viaje). De manera que la salida completa presenta el siguiente aspecto:

3

2

1

¡Despegando!

Como segundo ejemplo, consideremos de nuevo las funciones nuevaLinea and tresLineas.

   1: def nuevaLinea():

   2:     print    

   3: def 

   4:     tresLineas():

   5:     nuevaLinea()

   6:     nuevaLinea()

   7:     nuevaLinea()

Aunque todas funcionan, no serían de mucha ayuda si quisiera mostrar 2 líneas nuevas o 106. Una mejor alternativa será:

   1: def nLineas(n):

   2: if n > 0:

   3: print

   4: nLineas(n-1)

Este programa es parecido a cuenta atras; mientras n sea mayor que cero, muestra una nueva l³nea, y luego se llama a sí misma para mostrar >n-1 nuevas líneas mas. De esta manera, el numero total de nuevas l³neas es 1 + (n-1), que si rescata su algebra vera que es n.

El proceso por el que una funcion se llama a s³ misma se llama recursividad, y dichas funciones se denominan recursivas.

El la Sección 3.11 utilizamos un diagrama de pila para representar el estado de un programa durante la llamada de una función. El mismo tipo de diagrama puede hacer mas fácil interpretar una función recursiva.

Cada vez que se llama a una función, Python crea un nuevo marco para la función, que contiene sus variables locales y parámetros. En el caso de una función recursiva, puede haber mas de un marco en la pila al mismo tiempo.

La figura muestra un diagrama de pila para cuenta atrás, invocada con n = 3:

Como es habitual, en lo alto de la pila esta el marco de main . Esta vac³a porque no hemos ninguna variable sobre main ni le hemos pasado ningún parámetro.

Los cuatro marcos de cuenta atrás tienen valores diferentes para el parámetro n. El fondo de la pila, donde n=0, se llama caso base. No hace una llamada recursiva, de manera que no hay mas marcos.

Como actividad, dibuje un diagrama de pila para nLineas, invocada con el parámetro n=4.

Los programas que hemos escrito hasta ahora son un poco maleducados en el sentido de que no aceptan entradas de datos del usuario.

Simplemente hacen lo mismo siempre.

Python proporciona funciones internas que obtienen entradas desde el teclado.

La mas sencilla se llama raw input. Cuando llamamos a esta función, el programa se detiene y espera a que el usuario escriba algo. Cuando el usuario pulsa la tecla Return o Entre, el programa se reanuda y raw input devuelve lo que el usuario escribió como tipo string:

   1: >>> entrada = raw_input ()

   2: ¿A que estas esperando?

   3: >>> print entrada A que estas esperando?

Antes de llamar a raw input es conveniente mostrar un mensaje que le pida al usuario el dato solicitado. Este mensaje se llama indicador (prompt en ingles).

Puede proporcionarle un indicador a raw input como argumento:

   1: >>> nombre = raw_input ("Como te llamas? ")

   2: Como te llamas? Hector, 

   3: heroe de los Troyanos!

   4: >>> print nombre

   5: Hector, heroe de los 

   6: Troyanos!

Si espera que la entrada sea un entero, utilice la función input. Por ejemplo:

   1: >>> indicador = 

   2: ... "Cual es la velocidad de una golondrina sin 

   3: carga?n"

   4: >>> velocidad = input (indicador)

Si el usuario teclea una cadena de números, se convertirá en un entero y se asignara a velocidad. Por desgracia, si el usuario escribe algo que no sea un dígito, el programa dará un error:

   1: >>> velocidad = input (indicador)

   2: Cual es la velocidad de una 

   3: golondrina sin carga?

   4: Se refiere usted a la golondrina europea o a la 

   5: africana?

   6: SyntaxError: invalid syntax

Para evitar este tipo de error, generalmente es buena idea usar raw input para obtener una cadena y usar entonces las funciones de conversión para convertir a otros tipos.

operador modulo: Operador, señalado con un signo de tanto por ciento ( %), que trabaja sobre enteros y devuelve el resto cuando un numero se divide entre otro.

expresión booleana: Una expresión que es cierta o falsa.

operador de comparación: Uno de los operadores que comparan dos valores: ==, !=, >, = y <=.

operador lógico: Uno de los operadores que combinan expresiones booleanas: and, or y not.

sentencia condicional: Sentencia que controla el flujo de ejecución de un programa dependiendo de cierta condición.

condición: La expresión booleana de una sentencia condicional que determina que rama se ejecutara.

sentencia compuesta: Estructura de Python que esta formado por una cabecera y un cuerpo. La cabecera termina en dos puntos (:). El cuerpo tiene una sangría con respecto a la cabecera.

bloque: Grupo sentencias consecutivas con el mismo sangrado.

cuerpo: En una sentencia compuesta, el bloque de sentencias que sigue a la cabecera de la sentencia.

anidamiento: Una estructura de programa dentro de otra; por ejemplo, una sentencia condicional dentro de una o ambas ramas de otra sentencia condicional.

recursividad: El proceso de volver a llamar a la función que se esta ejecutando en ese momento.

caso base: En una función recursiva, la rama de una sentencia condicional que no ocasiona una llamada recursiva.

recursividad infinita: Función que se llama a sí misma recursivamente sin alcanzar nunca el caso base. A la larga una recursión infinita provocara un error en tiempo de ejecución.

indicador: indicador visual que invita al usuario a introducir datos.