04 - Curso de Python - Condicionales y bucles en Python
Cualquier duda suelo atender en este foro de python
Todo el código de este curso de Python gratuito está en github https://github.com/chuidiang/chuidiang-ejemplos/tree/master/PYTHON/curso-python. En el capítulo 04 hay un un par de ficheros while-continue.py y while-break.py con el código de los ejemplos más largos en este capítulo. En línea comandos python tienes como arrancar la consola de comandos de python por si quieres ir probando lo relativo a variables y tipos de datos en python.
Anterior: 03 - Curso de Python - Listas Tuplas y Diccionarios en Python -- Índice: Curso de Python -- Siguiente: 05 - Curso de Python - Operadores aritmeticos y de cadenas.
Sentencias compuestas en python[editar]
Una sentencia simple no es más que una línea de python que hace algo. Hemos visto algunas senencias simples de Phyton en los capítulos anteriores, como crear una lista, una tupla, acceder a sus elementos, etc.
Esisten sin embargo sentencias compuestas, es decir, sentencias que se componen de varias líneas, formando un bloque y que se ejecutan más o menos juntas siempre.
Hay varios tipos de sentencias compuestas, que resumimos ahora brevemente, pero vemos con más detalle en los siguientes apartados.
- Condicionales. Es un conjunto de sentencias que se ejecutan si se cumple una condición. Por ejemplo "si te sale un seis en el dado, coge un premio".
- Bucles while. Es un conjunto de sentencias que se ejecutan continuamente mientras se cumpla una determinada condición. En un condicional las sentencias se ejecutan una sola vez si se cumple la condición. En el bucle while se ejecutan una y otra vez sin parar hasta que deje de cumplirse la condición. Por ejemplo, "mientras no me salga un seis en el dado, tira otra vez el dado".
- Bucles for. Es un conjunto de sentencias que se ejecutan un número fijo de veces, el que digamos. Por ejemplo, "tira tres veces el ddado"
Quedan también try y with, pero esas las veremos en otro capitulo, puesto que son más avanzadas.
Formato de las sentencias compuestas[editar]
Como has visto en los tres tipos de sentencias compuestas que hemos explicado, suele haber algún tipo de "indicación" de cuándo o cuántas veces se debe ejecutar el conjunto de sentencias. En python, para escribir esto, la "indicación" y el bloque de sentencias, se hace de esta forma
if condicion: sentencia1 sentencia2 sentencia3 sentencia4
En este ejemplo y por concretarlo, lo hemos hecho con un condicional. Veremos los detalles más adelante. Fijate que:
- Se pone la "indicación", en este caso la palabra
ifseguida de la condición y terminada en dos puntos. - Detrás las sentencias que quremos que se ejecuten. Para que Python sepa cuántas son, deben "sangrarse", es decir, poner espacios delante, igual en todas ellas. Por ello ves sentencia1, sentencia2 y sentencia3 desplazadas a la derecha.
- Finalmente, ya sin sangrado y verticalmente debajo de la i del
if, las sentencias que ya no forman parte de la sentencia compuesta.
Con esta estructura, si se cumple la condición, se ejecutarán sentencia1, sentencia2 y sentencia3. Luego seguirá la ejecución con sentencia4. Si no se cumple la condición, no se ejecutarán sentencia1, sentencia2 ni sentencia3. La ejecución ira directamente a sentencia4.
Ahora que tenemos la idea general, vamos con detalles de los tres tipos de sentencias compuestas
Condiciones[editar]
Puesto que las condiciones están ahí, vamos a ver tipos de condiciones que podemos poner, aunque no estén todas las posibilidades aquí referenciadas
| Operador | Descripción |
|---|---|
| < | Es menor que |
| <= | Es menor o igual que |
| > | Es mayor que |
| >= | Es mayor o igual que |
| == | Es igual que |
| != | Es distinto que |
| is | es el mismo objeto |
| is not | no es el mismo objeto |
Veamos alugnos ejemplos y explicamos con algo más de detalle los dos últimos.
False >>> 1<2 True >>> 1==4 False >>> 'a'<'b' True >>> 'pedro'<'juan' False >>> True>False True >>> True==False False >>> 'A'>='a' False
Estos son sencillos. Uncicamente destacar que True es mayor que False y que para letras, va por orden alfabético, pero las mayúsculas van antes que las minúsculas.
Los is y is not tiene más sentido con variables, sobre todo si son colecciones. Por ejemplo
>>> lista1=[1,2,3] >>> lista2 = lista1 >>> lista2 is lista1 True >>> lista3 = lista1.copy() >>> lista3 is lista1 False
En ambos casos, lista1, lista2 y lista3 van a tener los mismos elementos. Pero lista2 es una variable que tiene exactamente el mismo objeto lista que lista1. Es lo que pasa cuando hacemos la asignación lista2=lista1, ambas variables tiene la misma lista. Cambiando elementos en una, vemos el cambio reflejado también en la otra. El comparador is nos devuelve en este caso True
Sin embargo, con lista3 = lista1.copy() estamos guardando el lista3 una copia de la lista1. Ambas listas van a tener los mismos elementos, pero son dos listas distintas. Si tocamos elementos en una, no afecta a la otra. El operador is devuelve False en este caso.
Otro detalle más que vemos aquí
>>> lista1=[3,4,1,5] >>> lista2=[3,2,6,8] >>> lista1>lista2 True
Aquí Python hace la comparación comparando el primer elemento, el 3, si son iguales, compara el segundo y así sucesivamente. El resultado de lista1>lista2 es True o False. En el ejemplo, como el primer 3 de ambas lista es igual, compara el segundo, 4>2 que devuelve True
Sentencia if[editar]
La estructura general de esta sentencia es
if condicion1: sentencia1 sentencia2 ... elif condicion2: sentencia3 sentencia4 ... ... ... else: sentencian
Es decir, un if, la condición1, un dos puntos y debajo, sangradas, todas las sentencias que qureamos que se ejecuten si se cumple la condición1.
Podemos añadir detrás todos los elfi (else if) que queramos. Son condiciones adicionales que se mirarán sólo si no se cumple la condición anterior. Es decir, si condición1 se cumple, se ejecuta sentencia1, sentencia2, ... y ya no se mira nada más. Si condición1 no se cumple, entoces si mira el elif condicion2 para ver si se cumple y ejecutar entonces sentencia3, sentencia4, ... . Si hubiera más elif se irían mirando solo si no se cumple la condición del anterior. Finalmente, un else que sólo se ejecutará si no se cumple ninguna de las condiciones anteriores.
Veamoslo con un ejemplo
>>> mi_sueldo = 1500
>>> if mi_sueldo<1000:
... print('soy mileurista')
... elif mi_sueldo<3000:
... print('me pagan bien')
... elif mi_sueldo<10000:
... print('me pagan muuuuuy bien')
... else:
... print('Me estoy forrando')
...
me pagan bien
Digamos que mi sueldo es 1500€. En la sentencia if pasa lo siguiente:
- Si mi sueldo es menor de 1000€, sacamos por pantalla que soy mileurista y ya no se ejecuta nada más de los bloques siguientes.
- Si mi sueldo no era menor de 1000€, entonces se mira si es menor de 3000€ y si es así, sacamos por pantalla que me pagan bien. Ya no se ejecutarían los siguientes bloques.
- Si mu sueldo tampoco era menor de 3000€, se mira si es menor de 10000€ y si es así, sacampos por pantalla que nos están pagando muuuuuuuuy bien. Ya no se ejecutarían los siguientes bloques.
- Finalemnte, si mi sueldo es superior a 10000€ y por tanto no se ha cumplido ninguna de las condiciones anteriores, se ejecuta lo que dice el
else, que nos estamos forrando.
Fíjate que aunque se cumplen dos condiciones, la de sueldo merno de 3000€ y sueldo menor de 10000€, sólo se ejecuta el código de la primera condición que se cumpla.
Esta sintaxis se puede simplificar. No es obligatorio poner ningún elif ni es obligatorio poner else. Nos valdría solo con el if. Además, si sólo se va a ejecutar una sentencia en caso de cumplirse la condición, no hace falta ponerla en la siguiente línea con sangrado, podría ponerse todo en la misma línea, así
>>> mi_sueldo=2500
>>> if mi_sueldo>2000: print ('me pagan bien')
...
me pagan bien
Sentencia while[editar]
La sintaxis general es
while condicion: sentencia1 sentencia2 ... else: sentencia4 sentencia5 ... sentencian
Mientras se cumpla la condición, se ejecutarán sentencia1, sentencia2, ... de forma repetitiva. Cuando la condición deje de cumplirse, seguirá la ejecución por sentencian. La parte del else se ejecutará cuando termine el bucle. Veamoslo con un ejemplo concreto
>>> contador=0 >>> while contador<10: ... print(contador) ... contador = contador+1 ... 0 1 2 3 4 5 6 7 8 9
Metemos un 0 en una variable contador y luego el while. Mientras contador sea menor que 10, sacamos su valor por pantalla y lo incremantamos en 1. El resultado es que salen los números del 0 al 9, puesto que el sumar 1 y sacarlo por pantalla se ejecuta las veces necesarias hasta que contador no sea menor que 10. En el momento que contador valga 10, ya no se cumple la condición y se termina el bucle.
Dentro del bucle, si hay alguna iteración que no nos intersa, podemos escribir continue. Esto hará de nos saltemos las sentencias que quedan dentro del while y vayamos a la siguiente iteración.
contador=0
while contador<10:
contador=contador+1
if contador==5:
continue
print(contador)
# La salida es
2
3
4
6
7
8
9
10
En el bucle hemos puesto un condicional if. Si contador es 5, llamamos a continue. Esto hace que nos saltemos el resto de sentencias, print() en este ejemplo, y sigamos con la siguiente iteración. En la salida vemos que nos saltamos el 5. Si hubiera un else, al terminar el bucle se ejecutarían las sentencias del else
Fíjate en un detalle. Una de las sentencias del while es a su vez una secuencia compleja, un if. Aunque en este caso hemos puesto un if simple, podríamos meter ahí toda la complejidad del if si quisieramos: Varios elif, else, etc. Y fíajate que para saber qué van dentro del if, necesiamos sangrar las líneas respecto a la posición del if
Con break podemos terminar el bucle antes de que se cumpla la condición.
while contador<10:
contador=contador+1
if contador==5:
break
print(contador)
# La salida es
1
2
3
4
Es como el anterior, pero al poner break en vez de continue, el bucle termina del todo. Si hubiera un else, no se ejecutaría.
Veamos ahora un ejemplo con else, que se ejecuta cuando termina el bucle, siempre que no rompamos la ejecución con un break
contador=0
while contador<10:
contador=contador+1
if contador==5:
continue
print(contador)
else:
print('Se acabo')
print(contador)
# La salida es
1
2
3
4
6
7
8
9
10
Se acabo
10
Si cambiamos continue por break en este mismo ejemplo, veremos que la ejecución para en el 4 y que no sale por pantalla la parte del else
Sentencia for[editar]
La sintaxis para la sentencia for es
for variable in rango: sentencia1 sentencia2 ... else: sentencia3 sentencia4 ... sentencian
Donde rango es algún tipo de colección de valores (letras, núemros, lo que sea, no todos del mismo tipo) que se irán asignando a variable. En cada iteración, se ejecutarán sentencia1, sentencia2, ... con variable igual a un valor conreto del rango. Terminado el bucle, es decir, recorridas toas las variables del rango, se ejecutarán las sentencias del else
Vamos con un ejemplo sencillo
>>> lista=[1,'a',True] >>> for a in lista: ... print(a) ... 1 a True
Como vimos en 03 - Curso de Python - Listas Tuplas y Diccionarios en Python, [1,'a',True] es una lista de valores. for a in lista: va a ir metiendo en la variable a los valores de la lista uno por uno. Cada vez que mete un valor, se ejecutarán las sentencias dentro del for, en este caso el print(a) y se pasará al siguiente valor de la lista, hasta que se acabe el proceso. La salida de esas sentencias serán los valores de la lista, de uno en uno.
Como en whle, tenemos continue y break para saltarnos una iteración o bien para terminar el bucle. No ponemos aquí ejemplo porque es muy similar a los de while. Tampoco repetimos la parte del else por el mimo motivo. Y al igual que con while, si paramos el bucle con un break, no se ejecutará la parte del else
En rango podemos usar cualquiera de las colecciones que ya conocemos, por ejemplo, un conjunto
>>> conjunto={1,2,3,1,2}
>>> for i in conjunto:
... print(i)
...
1
2
3
Fijate que el conjunto no admite elementos repetidos, así que tenemos solo 3 elementos en el conjunto.
Para no tener que crear las colecciones a mano y tener una forma fácil de crear un rango de números consecutivos, tenemos la función range(inicio,fin,incremento) que devolverá una secuencia de números que comienza en inicio, se incrementa de incremento en incremento y termina cuando llega a fin (excluido el valor final). Algunos parámetros son opcionales, veamos tres ejemplos
>>> for a in range(3): ... print(a) ... 0 1 2
Si solo ponemos un parámetro, se entiende que el de inicio es cero y el incremento es 1. El valor final, excluido, será el que pongamos como parámetro, 3 en este caso.
>>> for a in range(4,7): ... print(a) ... 4 5 6
Si ponemos dos valores, son inicio y fin. El incremento se supone que es 1.
>>> for a in range(4,10,3): ... print(a) ... 4 7
Aqui se empieza en 4, se va de tres en tres y para antes de llegar o superar 10.
>>> for a in range(3,0,-1): ... print(a) ... 3 2 1
Podemos poner incrementos negativos si nos interesa una cuenta atrás.
Anterior: 03 - Curso de Python - Listas Tuplas y Diccionarios en Python -- Índice: Curso de Python -- Siguiente: 05 - Curso de Python - Operadores aritmeticos y de cadenas.