En el 

tutorial de Introducción ya hablamos sobre los operadores en Python.

Como te indiqué, los operadores son símbolos reservados por el propio
lenguaje que se utilizan para llevar a cabo operaciones sobre uno, dos o más
elementos llamados operandos. Los operandos pueden ser variables, literales,
el valor devuelto por una expresión o el valor devuelto por una función.

El ejemplo más típico que siempre viene a la mente es el operador suma,  + ,

que se utiliza para obtener la suma aritmética de dos valores:

>>> 9 + 1 # 9 y 1 son los operandos

10 # 10 es el resultado

En este tutorial entraremos más en detalle sobre los distintos tipos de

operadores disponibles en Python.

Índice – Todos los operadores en Python

 Operador de concatenación de cadenas de caracteres
 Operadores lógicos o booleanos
 Operadores de comparación
 Operadores aritméticos
 Operadores a nivel de bits
 Operadores de asignación
 Operadores de pertenencia
 Operadores de identidad
 Prioridad de los operadores en Python

Operador de concatenación de cadenas de

caracteres
Una de las operaciones más básicas cuando se trabaja con cadenas de
caracteres es la concatenación. Esto consiste en unir dos cadenas en una sola,
siendo el resultado un nuevo string.

La forma más simple de concatenar dos cadenas en Python es utilizando el

operador de concatenación  + :

>>> hola = 'Hola'

>>> python = 'Pythonista'
>>> hola_python = hola + ' ' + python # concatenamos 3 strings
>>> print(hola_python)
Hola Pythonista

En esta entrada puedes conocer otras formas de concatenar en Python más

avanzadas.

Operadores lógicos o booleanos

A la hora de operar con valores booleanos, tenemos a nuestra disposición los
operadores  and ,  or  y  not .

❗️ IMPORTANTE: Las operaciones  and ,  or  y  not  realmente no

devuelven  True  o  False , sino que devuelven uno de los operandos como
veremos en el cuadro de abajo.

A continuación te muestro cómo funcionan los operadores booleanos (en

orden de preferencia ascendente):
 Operació Resultado Descripción
n

a or b Si  a  se evalúa a falso, entonces Solo se evalúa el segundo

devuelve  b , si no devuelve  a operando si el primero es
falso

a and b Si  a  se evalúa a falso, entonces Solo se evalúa el segundo

devuelve  a , si no devuelve  b operando si el primero es
verdadero

not a Si  a  se evalúa a falso, entonces Tiene menos prioridad que
devuelve  True , si no otros operadores no
devuelve  False booleanos

Ejemplos:

>>> x = True
>>> y = False
>>> x or y
True
>>> x and y
False
>>> not x
False
>>> x = 0
>>> y = 10
>>> x or y
10
>>> x and y
0
>>> not x
True

Operadores de comparación
Los operadores de comparación se utilizan, como su nombre indica, para
comparar dos o más valores. El resultado de estos operadores siempre
es  True  o  False .

Operador Descripción

> Mayor que.  True  si el operando de la izquierda es estrictamente

mayor que el de la derecha;  False  en caso contrario.

>= Mayor o igual que.  True  si el operando de la izquierda es mayor

o igual que el de la derecha;  False  en caso contrario.

< Menor que.  True  si el operando de la izquierda es estrictamente

menor que el de la derecha;  False  en caso contrario.

<= Menor o igual que.  True  si el operando de la izquierda es menor

o igual que el de la derecha;  False  en caso contrario.

== Igual.  True  si el operando de la izquierda es igual que el de la

 Operador Descripción

derecha;  False  en caso contrario.

!= Distinto.  True  si los operandos son distintos;  False  en caso
contrario.

Ejemplos:

>>> x = 9
>>> y = 1
>>> x < y
False
>>> x > y
True
>>> x == y
False

Consideraciones sobre los operadores de comparación

Los objetos de diferentes tipos, excepto los tipos numéricos, nunca se

comparan igual. El operador  ==  siempre está definido, pero para algunos tipos
de objetos (por ejemplo, objetos de clase) es equivalente a is.

Las instancias no idénticas de una clase normalmente se comparan como no

iguales a menos que la clase defina el método  __eq__() .

Las instancias de una clase no se pueden ordenar con respecto a otras

instancias de la misma clase u otros tipos de objeto, a menos que la clase
defina los métodos  __lt__() ,  __gt__() .

Los operadores de comparación se pueden concatenar. Ejemplo:

# Las comparaciones siguientes son idénticas

>>> x = 9
>>> 1 < x and x < 20
True
>>> 1 < x < 20
True

Operadores aritméticos en Python

En cuanto a los operadores aritméticos, estos permiten realizar las diferentes
operaciones aritméticas del álgebra: suma, resta, producto, división, … Estos
operadores Python son de los más utilizados. El listado completo es el
siguiente:

Operador Descripción

+ Suma dos operandos.

– Resta al operando de la izquierda el valor del operando de la

derecha. Utilizado sobre un único operando, le cambia el signo.

* Producto/Multiplicación de dos operandos.

/ Divide el operando de la izquierda por el de la derecha (el

resultado siempre es un  float ).

% Operador módulo. Obtiene el resto de dividir el operando de la

 Operador Descripción

izquierda por el de la derecha.

// Obtiene el cociente entero de dividir el operando de la

izquierda por el de la derecha.

** Potencia. El resultado es el operando de la izquierda elevado a

la potencia del operando de la derecha.

>>> x = 7
>>> y = 2
>>> x + y # Suma
9
>>> x - y # Resta
5
>>> x * y # Producto
14
>>> x / y # División
3.5
>>> x % y # Resto
1
>>> x // y # Cociente
3
>>> x ** y # Potencia
49

Operadores a nivel de bits

Los operadores a nivel de bits actúan sobre los operandos como si fueran una
cadena de dígitos binarios. Como su nombre indica, actúan sobre los
operandos bit a bit. Son los siguientes:

Operació Descripción
n

x|y or bit a bit de x e y.

x^y or exclusivo bit a bit de x e y.

x&y and bit a bit de x e y.

x << n Desplaza x n bits a la izquierda.

x >> n Desplaza x n bits a la derecha.

~x not x. Obtiene los bits de x invertidos.

Supongamos que tenemos el entero 2 (en bits es 00010) y el entero 7 (00111).

El resultado de aplicar las operaciones anteriores es:

>>> x = 2
>>> y = 7
>>> x | y
7
>>> x ^ y
5
>>> x & y
2
>>> x << 1
4
>>> x >> 1
1
>>> ~x
-3

Operadores de asignación
El operador de asignación se utiliza para asignar un valor a una variable. Como
te he mencionado en otras secciones, este operador es el signo  = .

Además del operador de asignación, existen otros operadores de asignación

compuestos que realizan una operación básica sobre la variable a la que se le
asigna el valor.

Por ejemplo,  x += 1  es lo mismo que  x = x + 1 . Los operadores compuestos

realizan la operación que hay antes del signo igual, tomando como operandos
la propia variable y el valor a la derecha del signo igual.

A continuación, aparece la lista de todos los operadores de asignación

compuestos:

Operador Ejempl Equivalencia

o

+= x += 2 x=x+2
Operador Ejempl Equivalencia
o

-= x -= 2 x=x–2

*= x *= 2 x=x*2

/= x /= 2 x=x/2

%= x %= 2 x=x%2

//= x //= 2 x = x // 2

**= x **= 2 x = x ** 2

&= x &= 2 x=x&2

|= x |= 2 x=x|2
 Operador Ejempl Equivalencia
o

^= x ^= 2 x=x^2

>>= x >>= 2 x = x >> 2

<<= x <<= 2 x = x << 2

Operadores de pertenencia
Los operadores de pertenencia se utilizan para comprobar si un valor o
variable se encuentran en una secuencia ( list ,  tuple ,  dict ,  set  o  str ).

Todavía no hemos visto estos tipos, pero son operadores muy utilizados.

Operador Descripción

in Devuelve True si el valor se encuentra en una secuencia; False

en caso contrario.

not in Devuelve True si el valor no se encuentra en una secuencia;

 Operador Descripción

False en caso contrario.

A continuación vemos unos ejemplos que son muy intuitivos:

>>> lista = [1, 3, 2, 7, 9, 8, 6]

>>> 4 in lista
False
>>> 3 in lista
True
>>> 4 not in lista
True

Operadores de identidad
Por último, los operadores de identidad se utilizan para comprobar si dos
variables son, o no, el mismo objeto.

Operador Descripción

is Devuelve True si ambos operandos hacen referencia al mismo

objeto; False en caso contrario.

is not Devuelve True si ambos operandos no hacen referencia al

mismo objeto; False en caso contrario.
❗️ Recuerda: Para conocer la identidad de un objeto se usa la función  id() .

>>> x = 4
>>> y = 2
>>> lista = [1, 5]
>>> x is lista
False
>>> x is y
False
>>> x is 4
True

Prioridad de los operadores en Python

Al igual que ocurre en las matemáticas, los operadores en Python tienen un
orden de prioridad. Este orden es el siguiente, de menos prioritario a más
prioritario: asignación; operadores booleanos; operadores de comparación,
identidad y pertenencia; a nivel de bits y finalmente los aritméticos (con el
mismo orden de prioridad que en las matemáticas).

Este orden de prioridad se puede alterar con el uso de los paréntesis  () :

>>> x = 5
>>> y = 2
>>> z = x + 3 * y # El producto tiene prioridad sobre la suma
>>> z
11
>>> z = (x + 3) * y # Los paréntesis tienen prioridad
>>> z
16

Bueno, pues hemos llegado al final de este tutorial, en el cuál hemos repasado
todos los operadores clave de Python. No te pierdas los siguientes en los que
nos adentraremos en las estructuras de control de flujo: if, while y for.
Python if – Sentencia básica
En Python, la sentencia if se utiliza para ejecutar un bloque de código si, y solo
si, se cumple una determinada condición. Por tanto, if es usado para la toma
de decisiones.

La estructura básica de esta sentencia if es la siguiente:

if condición:

bloque de código

Es decir, solo si  condición  se evalúa a  True , se ejecutarán las sentencias que
forman parte de  bloque de código . En caso de que se evalúe a  False  no se
ejecutará ninguna sentencia perteneciente a  bloque de código .

Aquí,  condición  puede ser un literal, el valor de una variable, el resultado de

una expresión o el valor devuelto por una función.

En las expresiones es muy común usar los operadores booleanos y de

comparación.

❗️IMPORTANTE: El cuerpo del bloque está indicado con un sangrado mayor.

Dicho bloque termina cuando se encuentre la primera línea con un sangrado
menor.

Veamos un ejemplo:

x = 17
if x < 20:

print('x es menor que 20')

En el código anterior la variable  x  toma el valor  17 . En la línea 2, la condición de

la sentencia  if  evalúa si  x es menor que 20 . Como el valor devuelto por la
expresión es  True , se ejecuta el bloque del  if , mostrando por pantalla la
cadena  x es menor que 20 .

Veamos otro ejemplo:

valores = [1, 3, 4, 8]

if 5 in valores:

print('está en valores')

print('fin')

En este caso tenemos una lista de  valores . El if comprueba si el número  5  se
encuentra entre estos  valores . Como la expresión devuelve como
resultado  False , porque  5  no está entre los  valores , el código anterior
simplemente mostrará por pantalla la cadena  fin .

Si repetimos el ejemplo anterior, modificando la condición a esta otra  3 in

valores , el resultado del programa sería:

está en valores

fin

❗️ RECUERDA: En principio, en Python todos los objetos/instancias se evalúan

a  True  a excepción de  None ,  False ,  0  de todos los tipos numéricos y
secuencias/colecciones vacías, que se evalúan a  False .

Sentencia if … else
Hay ocasiones en que la sentencia  if  básica no es suficiente y es necesario
ejecutar un conjunto de instrucciones o sentencias cuando la condición se
evalúa a  False .

Para ello se utiliza la estructura  if ... else...  Esta es estructura es como

sigue:

if condición:

bloque de código (cuando condición se evalúa a True)

else:

bloque de código 2 (cuando condición se evalúa a False)

Imagina que estás implementado un programa en el que necesitas realizar la

división de dos números. Si divides un número entre 0, el programa lanzará un
error y terminará. Para evitar esto, podemos añadir una sentencia  if ...
else...  como en el ejemplo siguiente:

resultado = None

x = 10

y=2

if y > 0:

resultado = x / y

else:

resultado = f'No se puede dividir {x} entre {y}'

print(resultado)

El resultado del script anterior es  5.0 . Si ahora actualizamos el valor de  y  a  0 , el
resultado sería este otro:

No se puede dividir 10 entre 0

if … elif … else
También es posible que te encuentres situaciones en que una decisión
dependa de más de una condición.

En estos casos se usa una sentencia if compuesta, cuya estructura es como se

indica a continuación:

if cond1:

bloque cond1 (sentencias si se evalúa la cond1 a True)

elif cond2:

bloque cond2 (sentencias si cond1 es False pero cond2 es True)

...

else:

bloque else (sentencias si todas las condiciones se evalúan a False)

Es decir, en esta ocasión, se comprueba la condición  cond1 . Si se evalúa a  True ,

se ejecuta el bloque  bloque cond1  y después el flujo continúa después del
bloque if.

Sin embargo, si  cond1  se evalúa a  False , se comprueba la condición  cond2 . Si
esta se evalúa a  True , se ejecuta el bloque de sentencias  bloque cond2 . En caso
contrario, pasaría a comprobar la condición del siguiente  elif  y así
sucesivamente hasta que llegue al  else , que se ejecuta si ninguna de las
condiciones anteriores se evaluaron a  True .

Veamos un ejemplo. Imagina que queremos comprobar si un número es

menor que 0, igual a 0 o mayor que 0 y en cada situación debemos ejecutar un
código diferente. Podemos hacer uso de la estructura if … elif … else anterior:

x = 28

if x < 0:

print(f'{x} es menor que 0')

elif x > 0:

print(f'{x} es mayor que 0')

else:
print('x es 0')

En el ejemplo anterior  x  toma el valor  28 . La primera condición de la

sentencia  if  se evalúa a  False  y pasa a la siguiente (a la del bloque  elif ). En
esta ocasión, la expresión se evalúa a  True , mostrándose por pantalla la
cadena  28 es mayor que 0 .

Sentencias if anidadas
Para terminar este tutorial, simplemente me gustaría añadir que en cualquiera
de los bloques de sentencias anteriores se puede volver a incluir una sentencia
if, o if … else … o if … elif … else …

Por ejemplo, podemos simular el caso de la última sección de la siguiente

manera:

x = 28

if x < 0:

print(f'{x} es menor que 0')

else:

if x > 0:

print(f'{x} es mayor que 0')

else:

print('x es 0')
La sentencia while en Python
Como te decía, el uso principal de la sentencia while es ejecutar repetidamente
un bloque de código mientras se cumpla una condición.

La estructura de esta sentencia while es la siguiente:

while condición:
bloque de código

Es decir, mientras  condición  se evalúe a  True , se ejecutarán las instrucciones y

sentencias de  bloque de código .

Aquí,  condición  puede ser un literal, el valor de una variable, el resultado de

una expresión o el valor devuelto por una función.

❗️ IMPORTANTE: El cuerpo del bloque while está indicado con un sangrado

mayor. Dicho bloque termina cuando se encuentre la primera línea con un
sangrado menor.

Veamos un ejemplo:

numero = 0
print('Tabla del 3')
while numero <= 10:
print(f'{numero * 3}')
numero += 1
print('Fin')

En el script anterior se inicializa una variable  numero  con el valor  0 .

Seguidamente se muestra un mensaje y en la línea 3 aparece una

sentencia while. En esta sentencia se comprueba si el valor de la
variable  numero  es menor o igual a  10 .

Como se evalúa a  True , se muestra por pantalla el resultado de

multiplicar  numero  por  3  y después se incrementa el valor de  numero  en  1 .

A continuación, se debería ejecutar el código de la línea 6. Sin embargo, como

hemos definido un bucle while, el flujo de ejecución del programa no continúa
por la línea 6, sino que vuelve a la línea 3 y de nuevo se evalúa si la
expresión  numero <= 10  sigue siendo  True . En esta ocasión el valor
de  numero  es  1 , por lo que la expresión da como resultado  True  y vuelven a
ejecutarse las líneas de la sentencia while.

Esto será así hasta que  numero  sea igual a  11 . En esa ocasión la expresión de
comparación se evaluará a  False  y el flujo continuará, ahora sí, por la línea 6.

El resultado del script anterior es el siguiente (la tabla de multiplicar del

número 3):

Tabla del 3
0
3
6
9
12
15
18
21
24
27
30
Fin
 Bucle while en Python – Ejemplo típico
La sentencia while la puedes usar en multitud de ocasiones. A continuación te
mostraré un escenario típico de uso de bucle while: Comprobar si existe un
elemento en una secuencia.

Imagina que tienes la siguiente lista de valores  [5, 1, 9, 2, 7, 4]  y quieres

saber si el número 2 está contenido en dicha lista. La estructura típica de bucle
while para ello es como sigue:

valores = [5, 1, 9, 2, 7, 4]
encontrado = False
indice = 0
longitud = len(valores)
while not encontrado and indice < longitud:
valor = valores[indice]
if valor == 2:
encontrado = True
else:
indice += 1
if encontrado:
print(f'El número 2 ha sido encontrado en el índice {indice}')
else:
print('El número 2 no se encuentra en la lista de valores')

Como puedes observar, en el ejemplo, se utilizan 3 variables de control:

 encontrado : Indica si el número 2 ha sido encontrado en la lista.

 indice : Contiene el índice del elemento de la lista  valores  que va a ser
evaluado.
 longitud : Indica el número de elementos de la lista  valores .

En esta ocasión, la condición de continuación del bucle while es que no se haya

encontrado el número 2 y que el índice del elemento a evaluar sea menor que
la longitud de la lista (es posible acceder a un elemento de una lista a partir del
índice de su posición, comenzando por 0).

Por tanto, el bucle finaliza bien cuando se haya encontrado el elemento, bien
cuando se haya evaluado el último elemento de la lista. Si se ha encontrado el
 número 2, se muestra un mensaje indicando el índice en el que está. En caso
contrario, se muestra un mensaje indicando que el número 2 no se encuentra
en la lista.

❗️ NOTA: El anterior es solo un ejemplo para que veas cómo funciona la

sentencia while. En realidad, en Python se puede usar el operador  in  para
comprobar de forma más eficiente si un elemento está contenido en una
secuencia.

Bucle while … else …

Al igual que sucede con el bucle for, podemos alterar el flujo de ejecución del
bucle while con las sentencias  break  y  continue :

 break  se
utiliza para finalizar y salir el bucle, por ejemplo, si se cumple
alguna condición.
 Por su parte,  continue  salta al siguiente paso de la iteración, ignorando
todas las sentencias que le siguen y que forman parte del bucle.

Veamos el ejemplo de la sección anterior modificado, añadiendo la

sentencia  break :

valores = [5, 1, 9, 2, 7, 4]
encontrado = False
indice = 0
longitud = len(valores)
while indice < longitud:
valor = valores[indice]
if valor == 2:
encontrado = True
break
else:
indice += 1
if encontrado:
print(f'El elemento 2 ha sido encontrado en el índice {indice}')
else:
print('El elemento 2 no se encuentra en la lista de valores')

Lo que he hecho ha sido eliminar de la condición de continuación del bucle la

comprobación de la variable  encontrado . Además, he añadido la
sentencia  break  si el número 2 se encuentra en la lista.

Por otro lado, al bucle while le podemos añadir la sentencia opcional  else . El

bloque de código del  else  se ejecutará siempre y cuando la condición de la
sentencia while se evalúe a  False  y no se haya ejecutado una sentencia  break .

Continuando con el ejemplo anterior, lo podemos modificar del siguiente

modo:

valores = [5, 1, 9, 2, 7, 4]
indice = 0
longitud = len(valores)
while indice < longitud:
valor = valores[indice]
if valor == 2:
print(f'El elemento 2 ha sido encontrado en el índice {indice}')
break
else:
indice += 1
else:
print('El elemento 2 no se encuentra en la lista de valores')

En esta ocasión se ha eliminado completamente el uso de la variable de

control  encontrado .
El bucle for en python
El bucle for se utiliza para recorrer los elementos de un objeto iterable (lista,
tupla, conjunto, diccionario, …) y ejecutar un bloque de código. En cada paso
de la iteración se tiene en cuenta a un único elemento del objeto iterable,
sobre el cuál se pueden aplicar una serie de operaciones.

Su sintaxis es la siguiente:

for <elem> in <iterable>:

<Tu código>

Aquí,  elem  es la variable que toma el valor del elemento dentro del iterador en
cada paso del bucle. Este finaliza su ejecución cuando se recorren todos los
elementos.

Como te indicaba, es muy frecuente usar el bucle for para iterar sobre los
elementos de listas, tuplas o diccionarios.

Ejemplo de cómo usar el bucle for

Imaginemos que tenemos una lista de números y queremos mostrarlos por

consola. El código podría ser así:
nums = [4, 78, 9, 84]
for n in nums:
print(n)
4
78
9
84

Qué es un iterable
Veamos con más detalle el concepto de iterable mencionado en el apartado
anterior. Un iterable es un objeto que se puede iterar sobre él, es decir, que
permite recorrer sus elementos uno a uno. Para ser más técnico, un objeto
iterable es aquél que puede pasarse como parámetro de la función  iter() .

Esta función devuelve un iterador basado en el objeto iterable que se pasa

como parámetro.

Finalmente, un iterador es un objeto que define un mecanismo para recorrer

los elementos del iterable asociado.

Te lo enseño mejor con un ejemplo:

>>> nums = [4, 78, 9, 84]

>>> it = iter(nums)
>>> next(it)
4
>>> next(it)
78
>>> next(it)
9
>>> next(it)
84
>>> next(it)
Traceback (most recent call last):
File "<input>", line 1, in <module>
StopIteration
Como puedes observar, un iterador recorre los elementos de un iterable solo
hacia delante. Cada vez que se llama a la función  next()  se recupera el
siguiente valor del iterador.

En Python, los tipos principales  list ,  tuple ,  dict ,  set  o  string  entre otros, son
iterables, por lo que podrán ser usados en el bucle for.

Bucle for en diccionarios

Un caso es especial de bucle for se da al recorrer los elementos de un
diccionario. Dado que un diccionario está compuesto por pares clave/valor,
hay distintas formas de iterar sobre ellas.

1 – Recorrer las claves del diccionario.

valores = {'A': 4, 'E': 3, 'I': 1, 'O': 0}

for k in valores:
print(k)
A
E
I
O

2 – Iterar sobre los valores del diccionario

valores = {'A': 4, 'E': 3, 'I': 1, 'O': 0}

for v in valores.values():
print(v)
4
3
1
0

3 – Iterar a la vez sobre la clave y el valor de cada uno de los elementos del
diccionario.

valores = {'A': 4, 'E': 3, 'I': 1, 'O': 0}

for k, v in valores.items():
print('k=', k, ', v=', v)
 k=A, v=4
k=E, v=3
k=I, v=1
k=O, v=0

Python for y la clase range

¿Cómo implementamos y/o simulamos en Python el bucle for basado en una
secuencia numérica? Para estos casos, Python pone a nuestra disposición la
clase  range  (en Python 2 era una función). El constructor de esta
clase,  range(max) , devuelve un iterable cuyos valores van desde  0  hasta  max - 1 .

for i in range(11):
print(i)
0
1
2
3
...
10

El tipo de datos  range  se puede invocar con uno, dos e incluso tres parámetros:

 range(max) : Un iterable de números enteros consecutivos que empieza

en  0  y acaba en  max - 1
 range(min, max) :
Un iterable de números enteros consecutivos que
empieza en  min  y acaba en  max - 1
 range(min, max, step) :
Un iterable de números enteros consecutivos que
empieza en  min  acaba en  max - 1  y los valores se van incrementando
de  step  en  step . Este último caso simula el bucle for con variable de control.

Por ejemplo, para mostrar por pantalla los números pares del 0 al 10
podríamos usar la función  range  del siguiente modo:

for num in range(0, 11, 2):

print(num)
0
2
 4
6
8
10

for _ in <iterable>
En ocasiones, es posible que el elemento actual del iterable que se está
recorriendo sea irrelevante. En estos casos puedes usar la variable  _  para
indicar esta situación. No obstante, yo no te lo recomiendo ya que también se
suele usar en librerías de traducciones de texto. Aún así, te muestro un caso
de uso. Imagínate que queremos implementar una función que devuelva la
longitud de una lista. El código podría ser como el que te muestro a
continuación:

def longitud(mi_lista):
cont = 0
for _ in mi_lista:
cont += 1
return cont

Modificando la iteración del bucle for: break y

continue
Por último, vamos a ver que es posible alterar la iteración de un bucle for en
Python. Para ello, nos valdremos de las sentencias  break  y  continue . Pero, ¿qué
hacen estas sentencias?

 break  se
utiliza para finalizar y salir el bucle, por ejemplo, si se cumple
alguna condición.
 Por su parte,  continue  salta al siguiente paso de la iteración, ignorando
todas las sentencias que le siguen y que forman parte del bucle.

Un ejemplo es la mejor manera de entenderlo.

Uso de break. Encontrar un elemento en una colección

coleccion = [2, 4, 5, 7, 8, 9, 3, 4]
for e in coleccion:
if e == 7:
break
print(e)

El código anterior mostrará los números 2, 4 y 5.

Uso de continue. Imprimir solo los números pares de una

colección

coleccion = [2, 4, 5, 7, 8, 9, 3, 4]
for e in coleccion:
if e % 2 != 0:
continue
print(e)

En este caso, el código anterior mostrará los números 2, 4, 8 y 4.

for … else
En relación al apartado anterior, Python ofrece una estructura adicional de
bucle  for  cuya estructura es la siguiente:

for e in iterable:
# Tu código aquí
else:
# Este código siempre se ejecuta si no
# se ejecutó la sentencia break en el bloque for

Es decir, el código del bloque  else  se ejecutará siempre y cuando no se haya
ejecutado la sentencia  break  dentro del bloque del  for .
Veamos un ejemplo:

numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
if n == 3:
break
else:
print('No se encontró el número 3')

Como en el ejemplo anterior la secuencia  numeros  contiene al número  3 , la

instrucción  print  nunca se ejecutará.

Conclusión
En este tutorial hemos repasado los aspectos más importantes del bucle for en
Python. Esta estructura de control es clave para trabajar colecciones.

También hemos visto el concepto de iterable e iterador en Python. Son los

objetos en los que se basa la operativa del bucle for.

Por último, se ha explicado cómo simular en Python un bucle for basado en

rango numérico y variable de control y cómo alterar la iteración con las
sentencias break y continue.
cadena1 = 'tengo una yama que Yama se llama' # declara variable
lista1 = ['pera', 'manzana', 'naranja', 'uva'] # declara lista
longitud = len(cadena1) # 32, devuelve longitud de la cadena
elem = len(lista1) # 4, devuelve nº elementos de la lista
cuenta = cadena1.count('yama') # 1, cuenta apariciones de 'yama'
print(cadena1.find('yama')) # 10, devuelve posición de búsqueda
cadena2 = cadena1.join('***') # inserta cadena1 entre caracteres
lista1 = cadena1.split(' ') # divide cadena por separador → lista
tupla1 = cadena1.partition(' ') # divide cadena por separador → tupla
cadena2 = cadena1.replace('yama','cabra',1) # busca/sustituye términos
numero = 3.14 # asigna número con decimales
cadena3 = str(numero) # convierte número a cadena
if cadena1.startswith("tengo"): # evalúa si comienza por “tengo”
if cadena1.endswith("llama"): # evalúa si termina por “llama”
if cadena1.find("llama") != -1: # evalúa si contiene “llama”
cadena4 = 'Python' # asigna una cadena a una variable
print(cadena4[0:4]) # muestra desde la posición 0 a 4: "Pyth"
print(cadena4[1]) # muestra la posición 1: "y"
print(cadena4[:3] + '-' + cadena4[3:]) # muestra "Pyt-hon"
print(cadena4[:-3]) # muestra todo menos las tres últimas: "Pyt"

# declara variable con cadena alfanumérica

cadena5 = " abc;123 "

# suprime caracteres en blanco (y \t\n\r) por la derecha

print(cadena5.rstrip()) # " abc;123"

# suprime caracteres en blanco (y \t\n\r) por la izquierda

print(cadena5.lstrip()) # "abc;123 "

# suprime caracteres en blanco (y \t\n\r) por derecha e izquierda

print(cadena5.strip()) # "abc;123"
# suprime caracteres del argumento por la derecha e izquierda
print(cadena5.strip("123456790; ")) # "abc"

cadena6 = "Mar" # declara una variable

print(cadena5.upper()) # convierte a mayúsculas: "MAR"
print(cadena5.lower()) # convierte a minúsculas: "mar"
 
Operaciones con listas y tuplas

lista1 = ['uno', 2, True] # declara una lista heterogénea

lista2 = [1, 2, 3, 4, 5] # declara lista numérica (homogénea)
lista3 = ['nombre', ['ap1', 'ap2']] # declara lista dentro de otra
lista4 = [54,45,44,22,0,2,99] # declara una lista numérica
print(lista1) # ['uno', 2, True], muestra toda la lista
print(lista1[0]) # uno, muestra el primer elemento de la lista
print(lista2[-1]) # 5, muestra el último elemento de la lista
print(lista3[1][0]) # calle, primer elemento de la lista anidada
print(lista2[0:3:1]) # [1,2,3], responde al patrón inicio:fin:paso
print(lista2[::-1]) # devuelve la lista ordenada al revés
lista1[2] = False # cambia el valor de un elemento de la lista
lista2[-2] = lista2[-2] + 1 # 4+1 → 5 – cambia valor de elemento
lista2.pop(0) # borra elemento indicado o último si no indica
lista1.remove('uno') # borra el primer elemento que coincida
del lista2[1] # borra el segundo elemento (por índice)
lista2 = lista2 + [6] # añade elemento al final de la lista
lista2.append(7) # añade un elemento al final con append()
lista2.extend([8, 9]) # extiende lista con otra por el final
lista1.insert(1, 'dos') # inserta nuevo elemento en posición
del lista2[0:3] # borra los elementos desde:hasta
lista2[:] = [] # borra todos los elementos de la lista
print(lista1.count(2)) # cuenta el nº de veces que aparece 2
print(lista1.index("dos")) # busca posición que ocupa elemento
lista3.sort() # ordena la lista
lista3.sort(reverse=True) # ordena la lista en orden inverso
lista5 = sorted(lista4) # ordena lista destino
tupla1 = (1, 2, 3) # declara tupla (se usan paréntesis)...
tupla2 = 1, 2, 3 # ...aunque pueden declararse sin paréntesis
tupla3 = (100,) # con un elemento hay terminar con “,”
tupla4 = tupla1, 4, 5, 6 # anida tuplas
tupla5 = () # declara una tupla vacía
tupla6 = tuple([1, 2, 3, 4, 5]) # Convierte una lista en una tupla
tupla2[0:3] # (1, 2, 3), accede a los valores desde:hasta
Diccionarios o matrices asociativas

Los diccionarios son objetos que contienen una lista de parejas de elementos. De cada pareja un
elemento es la clave, que no puede repetirse, y, el otro, un valor asociado. La clave que se utiliza
para acceder al valor tiene que ser un dato inmutable como una cadena, mientras que el valor
puede ser un número, una cadena, un valor lógico (True/False), una lista o una tupla.

Los pares clave-valor están separados por dos puntos, las parejas por comas y todo el conjunto
se encierra entre llaves.
Ejemplos:

capitales = {'Chile':'Santiago', 'España':'Madrid', 'Francia':'París'}

Para definir un diccionario vacío hay dos opciones:

capitales = {}
capitales = dict()

En el siguiente ejemplo se realizan algunas operaciones típicas con un diccionario:

# declara diccionario
capitales = {'Chile':'Santiago',
'España':'Madrid',
'Francia':'París'}

print('La capital de Chile es', capitales['Chile']) # 'Santiago'

del capitales['Francia'] # borra el par Francia:París
print('\nHay {0} países\n'.format(len(capitales))) # 'Hay 2 países'
for pais, capital in capitales.items(): # recorre diccionario
print('Capital de {0}: {1}'.format(pais, capital)) # muestra par

capitales['Portugal'] = 'Lisboa' # agrega par Portugal:Lisboa

if 'Portugal' in capitales: # comprueba si existe clave
print('\nCapital Portugal:', capitales['Portugal']) # 'Lisboa'

Operaciones con diccionarios

dic1 = {'Lorca':'Escritor', 'Goya':'Pintor'} # declara diccionario

print(dic1) # {'Goya': 'Pintor', 'Lorca': 'Escritor'}
dic2 = dict((('mesa',5), ('silla',10))) # declara a partir de tupla
dic3 = dict(ALM=5, CAD=10) # declara a partir de cadenas simples
dic4 = dict([(z, z**2) for z in (1, 2, 3)]) # declara a partir patrón
print(dic4) # muestra {1: 1, 2: 4, 3: 9}
print(dic1['Lorca']) # escritor, acceso a un valor por clave
print(dic1.get('Gala', 'no existe')) # acceso a un valor por clave
if 'Lorca' in dic1: print('está') # comprueba si existe una clave
print(dic1.items()) # obtiene una lista de tuplas clave:valor
print(dic1.keys()) # obtiene una lista de las claves
print(dic1.values()) # obtiene una lista de los valores
dic1['Lorca'] = 'Poeta' # añade un nuevo par clave:valor
dic1['Amenabar'] = 'Cineasta' # añade un nuevo par clave:valor
dic1.update({'Carreras' : 'Tenor'}) # añadir con update()
del dic1['Amenábar'] # borra un par clave:valor
print(dic1.pop('Amenabar', 'no está')) # borra par clave:valor
Recorrer secuencias y diccionarios con for...in
artistas = {'Lorca':'Escritor', 'Goya':'Pintor'} # diccionario
paises = ['Chile','España','Francia','Portugal'] # declara lista
capitales = ['Santiago','Madrid','París','Lisboa'] # declara lista
for c, v in artistas.items(): print(c,':',v) # recorre diccionario
for i, c in enumerate(paises): print(i,':',c) # recorre lista
for p, c in zip(paises, capitales): print(c,' ',p) # recorre listas
for p in reversed(paises): print(p,) # recorre en orden inverso
for c in sorted(paises): print(c,) # recorre secuencia ordenada

Importante: A partir de Python 3.6 la implementación de los diccionarios ha cambiado,

manteniéndose en todo momento el orden en que fueron agregados los elementos a un diccionario
cuando son recorridos o consultados.

Relacionado:

 Con OrderedDict el orden ha llegado

 Bucles eficaces con Itertools

Recorrer rangos con for... in range()

for num in range(7): print(num) # recorre de 0 a 6

for num in range(1,8): print(num) # recorre de 1 a 7
for num in range(10,50,5): print(num) # de 10 a 45 de 5 en 5
for num in range(0,-10,-1): print(num) # de 0 a -9 de -1 en -1

lista = ["Chorizo","Jamón","Morcilla","Salchichón"] # lista

for elemento in range(len(lista)): # recorre elementos de lista
print (elemento, lista[elemento]) # muestra posición y elemento
Operadores para secuencias: in, not in, is, is not

cadena = 'Python' # asigna cadena a variable

lista = [1, 2, 3, 4, 5] # declara lista
if 'y' in cadena: print('“y” está en “Python”') # contiene
if 6 not in lista: print('6 no está en la lista') # no contiene
if 'abcabc' is 'abc' * 2: print('Son iguales') # son iguales
Conjuntos: set

Un conjunto es una lista de elementos donde ninguno de ellos está repetido. A partir de una lista,
en la que pueden haber elementos repetidos, con set es posible crear otra lista con todos los
elementos pero sin repetir ninguno. Además, si tenemos varias listas podemos realizar operaciones
de conjuntos de unión, diferencia, intersección y diferencia simétrica:

- diferencia, | unión, & intersección y ^ diferencia simétrica

Operaciones con conjuntos

conjunto = set() # Define un conjunto vacío

lista = ['vino', 'cerveza', 'agua', 'vino'] # define lista
bebidas = set(lista) # define conjunto a partir de una lista
print('vino' in bebidas) # True, 'vino' está en el conjunto
print('anis' in bebidas) # False, 'anis' no está en el conjunto
print(bebidas) # imprime {'agua', 'cerveza', 'vino'}
bebidas2 = bebidas.copy() # crea nuevo conjunto a partir de copia
print(bebidas2) # imprime {'agua', 'cerveza', 'vino'}
bebidas2.add('anis') # añade un nuevo elemento
print(bebidas2.issuperset(bebidas)) # True, bebidas es subconjunto
bebidas.remove('agua') # borra elemento
print(bebidas & bebidas2) # imprime elementos comunes
tapas = ['croquetas', 'solomillo', 'croquetas'] # define lista
conjunto = set(tapas) # crea conjunto (sólo una de croquetas)
if 'croquetas' in conjunto: # evalúa si croquetas está
conjunto1 = set('Python') # define conjunto: P,y,t,h,o,n
conjunto2 = set('Pitonisa') # define conjunto: P,i,t,o,n,s,a
print(conjunto2 - conjunto1) # aplica diferencia: s, i, a
print(conjunto1 | conjunto2) # aplica unión: P,y,t,h,o,n,i,s,a
print(conjunto1 & conjunto2) # intersección: P,t,o,n
print(conjunto1 ^ conjunto2) # diferencia simétrica: y,h,i,s,a