Avisar de contenido inadecuado

Python: Estructuras de control.

{
}

Ya conocemos los tipos básicos con los que podemos trabajar, sabemos que son las variables y que operaciones podemos realizar con ellas cada variable y tipo. Esto es lo primero que hay que conocer cuando uno se enfrenta a un nuevo lenguaje de programación.

Lo siguiente que aprenderemos antes de introducirnos de lleno en las particularidades de python son las estructuras de control, gracias a ellas, nuestros programas podrán tomar decisiones, repetir fragmentos de código, etc.

En este apartado, veremos como el tipo booleano coge una especial importancia, ya que prácticamente todas las estructuras que veremos en este capitulo hacen uso de ellos para decidir el camino a seguir. Estas condiciones por muy complejas que sean, siempre tendrán que acabar en un verdadero o falso (0 o 1), si verdadero ejecutaremos un fragmento de código y si falso ejecutaremos otro.

La primera sentencia que veremos será if (podriamos traducirlo a Si) y es del tipo condicional. La sentencia if toma una decisión basándose en el resultado de verdadero o falso de una expresión.

La estructura básica es:

if expresion:

Linea_1

Linea_2

Linea_3

Cuando el flujo del progra llege al if, se valorara expresion en caso de que expresion sea verdadera, se ejecutaran las lineas de código Linea_1 y Linea_2 por último se procesará Linea_3. Si al contrario expresion es falso (false), se omitirá todo el bloque del if y el programa continuará en la siguiente sentencia, en nuestro caso Linea_3.

Veamos un ejemplo.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

tip_num = "impar"

if (num % 2) == 0:

tip_num = "par"

print num, "es un numero", tip_num

bueno si no entendéis todo el código no os preocupéis, ahora nos centraremos solo en la sentencia if.

  • La primera linea pide al usuario que introduzca un número y lo guarda en la variable num.

  • La línea 2, declara y inicializa la variable tip_num con el valor de impar.

  • La última muestra un mensage por pantalla.

No, no nos hemos olvidado de la línea 3, veamos la sintaxis del comando if era.

If expresion:

tip_num = “par”

En este mismo momento tip_num tiene el valor de impar, la sentencia si expresión es true, se ejecutara el código que contiene el bloque del if y canviará el valor de la variable tip_num, si por el contrario es false, el programa saltará todas las líneas de codigo que pertenecen al bloque if.

Como veis todo el jugo está en expresion, cuyo resultado tiene que ser un booleano (true/false). En nuestro ejemplo expresión es.

(num % 2) == 0

La primera parte de la expresión, es la operación módulo, si hacemos memòria lo que hacia era dividir un número por otro (en este ejemplo num / 2) y devolvía el resto de la división. Refrescando un poco las matemáticas, al dividir por dos, el resto de la división solo pude ser 0 o 1.

Por lo tanto, al comparar el resultado con 0 solo sera true cuando el resultado sea 0, lo que es lo mismo, cuando num sea par y es eso precisamente lo que queremos saber.

Si el num es par la expresión nos quedará: 0 == 0 (true)

Si num es impar obtendremos: 1 == 0 (false)

Un rollo ya lo sé, y tal vez un pelín complicado para un primer ejemplo, pero es importante que entendáis que en este capitulo cuando hablemos de expresión, sepáis que nos estamos refiriendo a una combinación de operaciones dentro de una misma instrucción cuyo resultado siempre será un booleano (true o false).

If : else.

La utilidad de la sentencia if que hemos visto en el apartado anterior dejaba mucho que desear, ya que lo único que nos permitía era ejecutar una parte del código o no. La potencia de if, es que nos permite elegir entre dos caminos diferentes según el resultado de expresion.

If expresion:

si_cierto_esto

else:

si_falso_esto

 

Ahora podríamos reescribir nuestro ejemplo anterior de esta forma.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

if (num % 2) == 0:

tip_num = "par"

else

tip_num = "impar"

print num, "es un numero", tip_num

Aunque en el ejemplo no se vea, la diferencia de código es importantísima.

If : elif: else

Imaginaros que a demás de saber si un número es par o impar, quiero distinguir entre pares grandes y pares pequeños.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

 

if (num % 2) == 0:

if num > 100:

tip_num = "par Grande"

else:

tip_num = "par pequeño"

else

tip_num = "impar"

print num, "es un numero", tip_num

De esta forma podríamos anidar tantos if como queramos, el problema es que el código cada vez se hace más difícil. En estos casos tenemos los if anidados cuya sintaxis es:

If expresion:

si_cierto_esto

elif expresion:

si_cierto_esto

elif expresion:

si_cierto_esto

elif expresion:

si_cierto_esto

.

.

.

si_cierto_esto

else:

si_falso_esto

Como en los casos anteriores el último else es opcional. Podemos poner tantos elif como queramos, las distintas ramificaciones del bloque, se procesan por orden y de manera secuencial, valorará expresión por expresión, empezando por la primera hasta encontrar una que sea verdadera, en ese momento ejecutara el modulo de código de rama correspondiente y cuando lo finalice saldrá del bloque if, sin valorar ninguna expresión más.

Esto quiere decir que en el bloque if pueden haber más de una instrucción cierta, pero el programa solo ejecutará la primera que encuentre. Veámoslo con un ejemplo, continuamos con nuestro código y lo adaptamos a los nuevos conocimientos adquiridos.

 

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

if (num % 2) == 0:

tip_num = "par pequeño"

elif (num % 2) == 0 and num > 100:

tip_num = "par Grande"

else

tip_num = "impar"

print num, "es un numero", tip_num

Este código presenta un problema, sabéis cual? Pues si, el programa nunca encontraría un par grande, ya que la primera expresión será siempre cierta para todos los número pares, por lo que la siguiente expresión nunca se evaluaria.

Un código más correcto podría ser este.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

if (num % 2) != 0:

tip_num = "impar"

elif num > 100:

tip_num = "par Grande"

else

tip_num = "par pequeño"

print num, "es un numero", tip_num

Esto se podía haber hecho de muchas formas diferentes, prueba tu ha hacerlo aplicando otras condiciones.

Hay un caso que se da muy a menudo y que se venia resolviendo con if. Son los casos en los que teníamos que asignar un valor A o B dependiendo de que una expresión sea cierta o no.

if expresion:

x = A

else:

x = B

En estos casos tenemos una alternativa.

X = si_cierto if expresion else si_falso

Con esto, el código anterior nos quedaría.

X = A if expresion else B

 

donde X seria igual a A si expresion = true.

X seria igual a B si expresion = false.

La sentencia while (mientras).

Esta instrucción repite todo su bloque de código mientras la expresión evaluada sea cierta.

While expresion:

hago

hago

hago

un ejemplo sencillito.

# [cuenta de 1 a 10]

num = 1

while num <= 10:

print num

num += 1

 

# Mientras num sea menor o igual que 10 se repetirá el codigo.

El funcionamiento es simple, el programa evalúa la expresión, si esta es cierta, ejecuta el código del bloque, cuando acaba vuelve a evaluar la expresión, si es cierta ejecuta nuevamente el código, así hasta que expresión devuelva false, en cuyo caso, se ejecutará la siguiente línea de código existente después del bloque while.

Si os ha quedado alguna duda, este nuevo ejemplo os las aclarará.

# [adivina un numero]

import random

num_pensado = random.randint(1, 10)

num_elegido = int(raw_input('Adivina que numero he pensado del 1 al 10: '))

veces = 0

while num_pensado != num_elegido:

num_elegido = int(raw_input('Fallaste!!! vuelvelo a intentar: '))

veces += 1

print "has acertado en ", veces, "intentos"

He colado alguna cosa que igual no sabeis aún que es lo que hace, ya lo veremos todo más adelante, ahora centraros solo en el bucle while y en su expresion.

Los bucles son uno de los principales problemas de cuelges en las aplicaciones, no es difícil entrar en un bucle en la cual su expresion siempre sea falsa.

# [Bucle infinito]

num = 1

while num <= 10:

print num

print “FIN”

En este caso se trata de un accidente, pero hay veces en el que nos puede interesar crear un bucle infinito.

# [hasta el infinito y mas alla]

while 1 == 1:

hago_algo

Igual que en el caso del if, while tambíen nos ofrece la posibilidad de modificar el flujo del programa.

while expresion:

hago_algo

if expresion: break #salgo de while

if expresion: continue #salto al inicio del while

hago_algo

else:

aveces_lo_hago

Veamos un ejemplos.

# [numero primo]

y = int ( raw_input("Introduce un numero: "))

x = y / 2

while x > 1:

if y % x == 0:

print y, 'es divisible por ', x

break

x = x - 1

else:

print y, 'es primo'

Si ejecutáis el código veréis que la instrucción else se ejecutará siempre y cuando finalizamos el bucle while de forma natural, osea cuando su expresión es false, si por el contrario salimos de while, mediante la instrucción break, el codigo que contiene el bloque else no será ejecutado.

Si dentro de un bucle se ejecuta la instrucción continue, saltaremos al inicio del bucle, ignorando todo el código restante que pudiese quedar, volviendo a evaluar la expresión del while y en caso de ser cierta, continuaríamos en la primera linea del bloque.

No se aconseja el uso de las instrucciones break y continue, aunque en un principio pueda parecer atractiva la idea, el uso de ellas crea programas difíciles de seguir.

For – in

Explicar esta instrucción sin haber explicado las listas es un poco difícil. Podríamos decir que lo que hace es recorrer una secuencia independientemente del tipo de datos, en definitiva se puede utilizar para cualquier objeto sobre los que podemos acceder a sus elementos de manera indexada.

Haremos una pequeña introducción y lo dejaremos hasta el siguiente capitulo donde explicaremos las listas.

La sintaxis.

For elemento in objeto:

. . .

else:

. . .

Igual que en while, podemos modificar el flujo del bucle con continue o break.

For x in ['paco', 'juan', 'antonio']:

print x

# [sumatorio]

sum = 0

for x in [1, 3, 4 ,5]:

sum + = x

print x

El primer for, repite 3 veces el código de su bloque (print x), en la primera interacción, x coge el valor de paco, en la segunda de juan y por último de antonio.

Por último un par de ejemplos más.

T = [(2, 1), (3, 1), (7, 2)]

for (x, y) in T:

print x, y

 

for i in range(10):

print i

Bueno, lo dicho en el siguiente capitulo veremos las listas y podremos explicar un poco mejor este ultimo bucle.

- - -

abre tu mente 1 + 1 = 10    (no siempre es dos)

{
}
{
}

Comentarios Python: Estructuras de control.

;-*
lucely lucely 30/11/2008 a las 16:12
jajaja cierto
Anónimo Anónimo 11/09/2010 a las 18:15
hola ya que explicas esta sentecnia me gustaria pregunutarte algo estoy practicando con python y no puedo echar a andar un pequeño codigo me gustaria si pudieras desirme que es  lo que estoy haciendo mal
#!/usr/bin/python

print "hola mundo"
raw_input("Respuesta: ")

print "mucho gusto, eres amigo"

Respuesta = raw_input ("Respuesta: ")
if Respuesta == "si"
print "que bien"
elif Respuesta == "no"
print "esta bien"
raw_input()
estoy usando ubuntu 9.10 y tambien lo he prbado en un interprete de windows pero no he logrado hacer que el escript se ejecute adecuadamente, solamente se me sierra antes de iniciar, bueno muchas gracias de antemano por tu ayuda.
manu manu 17/07/2011 a las 23:25
así a simple vista, yo pondría los dos puntos finales en la sentencia if y en elif y luego te falta la tabulación.
Buena info loca!!!Esta para masturbarse toda la noche bebota!
mast mast 10/08/2012 a las 00:06
Interesante blog, hace poco que estoy aprendiendo por mi cuenta python y quería saber si dentro de un bucle "for" dada una condición hay alguna forma de saltar pasos del indice "for" pero continuando el bucle, por ejemplo:
texto = 'Cariñosamente'
abecedario = 'abcdefghijklmnopqrstuvwxyz'
for i in texto:
if ord(i) == 195:
if ord(texto[i+1]) == 177:
caracter,ascii = 'ñ',177 # Si ocurre esto quiero saltarme 1 elemento i
else:
caracter,ascii = texto[i],abecedario.find(texto[i])
print '%s @ %d' % (caracter,ascii)
Pablo Villar Vega Pablo Villar Vega 24/03/2016 a las 18:13
Excelente aporte. Muchas gracias por la informacion!.
Estructuras Metalicas Estructuras Metalicas 06/12/2016 a las 15:30

Deja tu comentario Python: Estructuras de control.

Identifícate en OboLog, o crea tu blog gratis si aún no estás registrado.

Avatar Tu nombre