Saltar a contenido

3. Decisiones, bucles y listas

Operador de igualdad ==

Pregunta: ¿Son dos valores iguales?

Para hacer esta pregunta, se utiliza el operador == (igual igual).

2 == 2 # True
1 == 2 # False

El operador == compara los valores de dos operandos.Si son iguales, el resultado de la comparación es True. Si no son iguales, el resultado de la comparación es False.

Desigualdad (!=)

Pregunta: ¿Son dos valores distintos?

var = 0 # asignando 0 a var
print(var != 0) # False

var = 1 # asignando 1 a var
print(var != 0) # True

Operadores de comparación < <= > >=

<, <=, >, >=

Condiciones y ejecución condicional

x = 10

if x > 5:  # True
    if x == 6:  # False
        print("anidado: x == 6")
    elif x == 10:  # True
        print("anidado: x == 10")
    else:
        print("anidado: else")
else:
    print("else")

Bucles While

Ejecuta una sentencia o un conjunto de sentencias siempre que una condición booleana especificada sea verdadera.

# Almacena el actual número más grande aquí.
largest_number = -999999999

# Ingresa el primer valor.
number = int(input("Introduce un número o escribe -1 para detener: "))

# Si el número no es igual a -1, continuaremos
while number != -1:
    # ¿Es el número más grande que el valor de largest_number?
    if number > largest_number:
        # Sí si, se actualiza largest_number.
        largest_number = number
    # Ingresa el siguiente número.
    number = int(input("Introduce un número o escribe -1 para detener: "))

# Imprime el número más grande
print("El número más grande es:", largest_number)
i = 0
while i < 100:
    # do_something()
    i += 1

Bucles for

El bucle for ejecuta un conjunto de sentencias muchas veces; se usa para iterar sobre una secuencia (por ejemplo, una lista, un diccionario, una tupla o un conjunto.

Puedes usar el bucle for para iterar sobre una secuencia de números usando la función incorporada range. Mira los ejemplos a continuación:

for i in range(10):
    print("El valor de i es actualmente", i)

range()

La función range() genera una secuencia de números. Acepta enteros y devuelve objetos de rango. La sintaxis de range() tiene el siguiente aspecto:

range(start, stop, step), donde:

start:

es un parámetro opcional que especifica el número de inicio de la secuencia (0 por defecto)

stop:

es un parámetro opcional que especifica el final de la secuencia generada (no está incluido).

step:

es un parámetro opcional que especifica la diferencia entre los números en la secuencia es (1 por defecto.)

print(range(1,11)) # 11 es el número límite que no se tendrá en cuenta
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(range(1,11,2)) # el 2 indica el incremento
# [1, 3, 5, 7, 9]

Control de bucles | break y continue

break

sale del bucle inmediatamente, e incondicionalmente termina la operación del bucle; el programa comienza a ejecutar la instrucción más cercana después del cuerpo del bucle.

continue

se comporta como si el programa hubiera llegado repentinamente al final del cuerpo; el siguiente turno se inicia y la expresión de condición se prueba de inmediato.

El bucle while y la rama else

En el caso siguiente, el bucle se repetirá hasta que la condición se acabe, es decir cuando n > 0 sea False. Dado que el bucle ha acabado de forma "natural", la rama del else se ejecutará.

n = 5
while n > 0:
    n -= 1
    print(n)
else:
    print('hecho')

4
3
2
1
0
hecho

Sin embargo, en el siguiente caso, el loop acaba de forma prematura con break por lo que la claúsula else no se ejecutará.

n = 5
while n > 0:
    n -= 1
    print(n)
    if n == 2:
        break
else:
    print('Loop done.')

4
3
2
  • Piensa en el encabezado del loop (while n > 0) como una sentencia if que se ejecuta una y otra vez con la claúsula else siendo ejecutada al final, cuando la condición se vuelve false.
a = 6

while a > 0: # Equivale a un if que se ejecuta continuamente
    a -= 1
    if a == 0:
        continue    # pasa a la siguiente iteración
    print(a)

    if a == 5 :
        break # interrumple el bucle sin pasar por el else
else:
    print("else") # solo llegaremos aquí si el bucle se acaba naturalmente

print ("Fin")

El bucle for y la rama else

Sucede algo parecido al while, si el bucle finaliza de forma natural pasará por el else, pero si interrumpimos con un break no pasará:

for i in range(5):
    print(i)
else:
    print("else:", i)

0
1
2
3
4
else: 4
for a in range(0,10,1):
    if a == 6:
        break
    print(a)
else:
    print("else")

0
1
2
3
4
5

Operaciones lógicas y de bits

and

Operador de conjunción lógica. Es un operador binario con una prioridad inferior a la expresada por los operadores de comparación. Nos permite codificar condiciones complejas sin el uso de paréntesis:

counter > 0 and value == 100

not

Es un operador unario que realiza una negación lógica. Su funcionamiento es simple: convierte la verdad en falso y lo falso en verdad

print(not False == True)
True

Expresiones lógicas

# Ejemplo 1:
print(var > 0)
print(not (var <= 0))

# Ejemplo 2:
print(var != 0)
print(not (var == 0))

Leyes de De Morgan

  • La negación de una conjunción es la separación de las negaciones.

  • La negación de una disyunción es la conjunción de las negaciones.

lo mismo usando Python:

not (p and q) == (not p) or (not q)
not (p or q) == (not p) and (not q)

Valores lógicos frente a bits individuales

Los operadores lógicos toman sus argumentos como un todo, independientemente de cuantos bits contengan. Los operadores solo conocen el valor: cero (cuando todos los bits se restablecen) significa False; no cero (cuando se establece al menos un bit) significa True.

El resultado de sus operaciones es uno de estos valores: False o True.

Esto significa que este fragmento de código asignará el valor True a la variable j si i no es cero; de lo contrario, será False.

i = 1
j = not not i

Operadores bit a bit

Hay cuatro operadores que permiten manipular bits de datos individuales. Se denominan operadores bit a bit.

Aquí están todos ellos:

  • & (ampersand) - conjunción a nivel de bits.
  • | (barra vertical) - disyunción a nivel de bits.
  • ~ (tilde) - negación a nivel de bits.
  • ^ (signo de intercalación) - o exclusivo a nivel de bits (xor).

La diferencia en el funcionamiento de los operadores lógicos y de bits es importante: los operadores lógicos no penetran en el nivel de bits de su argumento. Solo les interesa el valor entero final.

Los operadores bit a bit son más estrictos: tratan con cada bit por separado.

Si asumimos que la variable entera ocupa 64 bits (lo que es común en los sistemas informáticos modernos), puede imaginar la operación a nivel de bits como una evaluación de 64 veces del operador lógico para cada par de bits de los argumentos. Su analogía es obviamente imperfecta, ya que en el mundo real todas estas 64 operaciones se realizan al mismo tiempo (simultáneamente).

Puntos Clave operadores

  1. Python es compatible con los siguientes operadores lógicos:

    and → si ambos operandos son verdaderos, la condición es verdadera, por ejemplo, (True and True) es True.

    or → si alguno de los operandos es verdadero, la condición es verdadera, por ejemplo, (True or False) es True.

    not → devuelve False si el resultado es verdadero y devuelve True si es falso, por ejemplo, not True es False.

  2. Operadores bit a bit

    x = 15, # 0000 1111 en binario.
    y = 16, # 0001 0000 en binario.
  • & hace un bit a bit and (y), por ejemplo, x & y = 0, el cual es 0000 0000 en binario.
  • | hace un bit a bit or (o), por ejemplo, x | y = 31, el cual es 0001 1111 en binario.
  • ˜ hace un bit a bit not (no), por ejemplo, ˜ x = 240, el cual es 1111 0000 en binario.
  • ^ hace un bit a bit xor, por ejemplo, x ^ y = 31, el cual es 0001 1111 en binario.
  • >> hace un desplazamiento bit a bit a la derecha, por ejemplo, y >> 1 = 8, el cual es 0000 1000 en binario.
  • << hace un desplazamiento bit a bit a la izquierda, por ejemplo, y << 3 = 128, el cual es 1000 0000 en binario.

Listas

La lista es un tipo de dato en Python que se utiliza para almacenar múltiples objetos. Es una colección ordenada y mutable de elementos separados por comas entre corchetes, por ejemplo:

my_list = [1, None, True, "Soy una cadena", 256, 0]
  • Se pueden indexar y actualizar , por ejemplo: my_list[1] = '?'

  • Son equivalentes a los arreglos en PHP o en Javascript.

  • Pueden estar anidadas: my_list = [1, 'a', ["lista", 64, [0, 1], False]]

Para crear una lista, simplemente se declaran sus elementos entre corchetes:

mi_lista = [1, 'b', 'd', 23]
mi_lista_vacia = [] # crea una lista sin elementos

Para agregar elementos a una lista, se utiliza el método append:

mi_lista.append(10)
print mi_lista
[1, 'b', 'd', 23, 10]

Para modificar un elemento particular de una lista, se asigna el nuevo valor al subíndice correspondiente:

mi_lista[0] = 2
print mi_lista
[2, 'b', 'd', 23, 10]

Incluso se pueden reemplazar trozos de una lista con otra, o con trozos de otra, usando la notación de rebanadas (slices):

mi_lista[0:2] = [3, 4] # reemplazar los dos primeros elementos de la lista con los elementos de [3, 4]
print mi_lista
[3, 4, 'd', 23, 10]

Es importante notar que lo anterior no es lo mismo que asignar una secuencia entera a un índice:

mi_lista[0] = [3, 4] # el primer elemento de mi_lista es ahora la lista [3, 4]
print mi_lista
[[3, 4], 4, 'd', 23, 10]

Los operadores in y not in

Se puede comprobar si un elemento pertenece o no a una secuencia con los operadores in y not in.

2 in lista
True
8 not in lista
True

Las listas poseen algunos métodos propios:

  • Eliminar un elemento con mi_lista.remove()
  • Reordenar la lista con mi_lista.sort()
  • invertir el orden con mi_lista.reverse()

Todas las secuencias pueden ser transformadas a listas usando la función list().

a = list(range(0,100,10))
print(a)
# [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

lista = [*range(1,13)]
print(lista)

b = list("Hola")
print(b)
# ['H', 'o', 'l', 'a']

Un elemento con un índice igual a -1 es el último en la lista, el -2 sería el penúltimo y así hacia atrás.

Recetas

Obtener los elementos mas frecuentes en una lista

from collections import Counter

numeros = [1,4,5,4,6,6,6,3,2,1,1,4,5,11,3,1]
contador = Counter(numeros)

print (contador.most_common(3))

[(1, 4), (4, 3), (6, 3)]

frase = "Python es extremadamente potente"
contador = Counter(frase)

print (contador.most_common(3))

[('e', 7), ('t', 5), ('n', 3)]

Obtener los elementos únicos de una lista

numeros = [7,0,9,76,4,2,4,6,4,7,65,4,3,6,2]
numeros_sin_repetir = set(numeros)
print (numeros_sin_repetir)
print (type(numeros_sin_repetir))
numeros = list(numeros_sin_repetir)
print (numeros)
print (type(numeros))

{0, 65, 2, 3, 4, 6, 7, 9, 76}
<class 'set'>
[0, 65, 2, 3, 4, 6, 7, 9, 76]
<class 'list'>

Obtener una cantidad n de elementos mínimos o máximos

import heapq

numeros = [1,4,5,6,11]

print (heapq.nsmallest(3, numeros))
print (heapq.nlargest(3, numeros))
[1, 4, 5]
[11, 6, 5]

productos = [
  {'nombre':'Mouse', 'precio':45},
  {'nombre':'Teclado', 'precio':145},
  {'nombre':'Monitor', 'precio':175},
  {'nombre':'Altavoces', 'precio':70},
  {'nombre':'Cable corriente', 'precio':30}
]

mas_barato = heapq.nsmallest(1, productos, key=lambda p: p['precio'])
print (mas_barato)

mas_caro = heapq.nlargest(1, productos, key=lambda p: p['precio'])
print (mas_caro)

mas_baratos = heapq.nsmallest(2, productos, key=lambda p: p['precio'])
print (mas_baratos)

Agrupar elementos de una lista especificando un campo de interés

from operator import itemgetter
from itertools import groupby

productos = [

    {'nombre':'Mouse', 'precio':35, 'fecha_venta': '2020/12/20'},
    {'nombre':'Cable corriente', 'precio':15, 'fecha_venta': '2020/12/20'},
    {'nombre':'Monitor', 'precio':175, 'fecha_venta': '2020/12/22'},
    {'nombre':'Tablet', 'precio':335, 'fecha_venta': '2020/12/22'},
    {'nombre':'Impresora', 'precio':125, 'fecha_venta': '2020/12/22'},
    {'nombre':'Smartphone', 'precio':235, 'fecha_venta': '2020/12/23'},
    {'nombre':'Scanner', 'precio':95, 'fecha_venta': '2020/12/27'},
    {'nombre':'Altavoces', 'precio':95, 'fecha_venta': '2020/12/29'},
]

productos.sort(key=itemgetter('fecha_venta'))

for fecha, elementos in groupby(productos, key=itemgetter('fecha_venta')):
    print(fecha)

    for elemento in elementos:
            print ('    ', elemento)


2020/12/20
     {'nombre': 'Mouse', 'precio': 35, 'fecha_venta': '2020/12/20'}
     {'nombre': 'Cable corriente', 'precio': 15, 'fecha_venta': '2020/12/20'}
2020/12/22
     {'nombre': 'Monitor', 'precio': 175, 'fecha_venta': '2020/12/22'}
     {'nombre': 'Tablet', 'precio': 335, 'fecha_venta': '2020/12/22'}
     {'nombre': 'Impresora', 'precio': 125, 'fecha_venta': '2020/12/22'}
2020/12/23
     {'nombre': 'Smartphone', 'precio': 235, 'fecha_venta': '2020/12/23'}
2020/12/27
     {'nombre': 'Scanner', 'precio': 95, 'fecha_venta': '2020/12/27'}
2020/12/29
     {'nombre': 'Altavoces', 'precio': 95, 'fecha_venta': '2020/12/29'}

Filtrar los elementos de una secuencia

numeros = [5,4,-6,3,-9,8,0,12]

print (numeros)

numeros_positivos = [n for n in numeros if n > 0 ]

print (numeros_positivos)

Ordenar una lista usando Diferentes Campos

from operator import itemgetter

productos = [
    {'id':1, 'nombre': 'Mouse','precio':35},
    {'id':5, 'nombre': 'Teclado','precio':75},
    {'id':3, 'nombre': 'Altavoz','precio':55},
    {'id':6, 'nombre': 'Monitor','precio':335},
    {'id':4, 'nombre': 'Tablet','precio':435}
]

productos_id = sorted(productos,key=itemgetter('id'))

print (productos_id)

productos_precio = sorted(productos,key=itemgetter('precio'))

print (productos_precio)

[{'id': 1, 'nombre': 'Mouse', 'precio': 35}, {'id': 3, 'nombre': 'Altavoz', 'precio': 55}, {'id': 4, 'nombre': 'Tablet', 'precio': 435}, {'id': 5, 'nombre': 'Teclado', 'precio': 75}, {'id': 6, 'nombre': 'Monitor', 'precio': 335}]

[{'id': 1, 'nombre': 'Mouse', 'precio': 35}, {'id': 3, 'nombre': 'Altavoz', 'precio': 55}, {'id': 5, 'nombre': 'Teclado', 'precio': 75}, {'id': 6, 'nombre': 'Monitor', 'precio': 335}, {'id': 4, 'nombre': 'Tablet', 'precio': 435}]

Ordenar objetos a partir de un campo arbitrario

from operator import attrgetter

class Usuario:

    def __init__(self, identificador, nombre):
        self.identificador = identificador
        self.nombre = nombre

    def __repr__(self):
        return '{} - {}'.format(self.identificador, self.nombre)


usuarios = [Usuario(7,'Eduardo'), Usuario(3,'Daniela'),Usuario(5,'Juan'),Usuario(10,'Silvia')]

print (sorted(usuarios,key=attrgetter('identificador')))
print (sorted(usuarios,key=attrgetter('nombre')))


[3 - Daniela, 5 - Juan, 7 - Eduardo, 10 - Silvia]
[3 - Daniela, 7 - Eduardo, 5 - Juan, 10 - Silvia]

Agrupar elementos de una lista especificando un campo de interés

from operator import itemgetter
from itertools import groupby

productos = [

    {'nombre':'Mouse', 'precio':35, 'fecha_venta': '2020/12/20'},
    {'nombre':'Cable corriente', 'precio':15, 'fecha_venta': '2020/12/20'},
    {'nombre':'Monitor', 'precio':175, 'fecha_venta': '2020/12/22'},
    {'nombre':'Tablet', 'precio':335, 'fecha_venta': '2020/12/22'},
    {'nombre':'Impresora', 'precio':125, 'fecha_venta': '2020/12/22'},
    {'nombre':'Smartphone', 'precio':235, 'fecha_venta': '2020/12/23'},
    {'nombre':'Scanner', 'precio':95, 'fecha_venta': '2020/12/27'},
    {'nombre':'Altavoces', 'precio':95, 'fecha_venta': '2020/12/29'},
]

productos.sort(key=itemgetter('fecha_venta'))

for fecha, elementos in groupby(productos, key=itemgetter('fecha_venta')):
    print(fecha)

    for elemento in elementos:
            print ('    ', elemento)


2020/12/20
     {'nombre': 'Mouse', 'precio': 35, 'fecha_venta': '2020/12/20'}
     {'nombre': 'Cable corriente', 'precio': 15, 'fecha_venta': '2020/12/20'}
2020/12/22
     {'nombre': 'Monitor', 'precio': 175, 'fecha_venta': '2020/12/22'}
     {'nombre': 'Tablet', 'precio': 335, 'fecha_venta': '2020/12/22'}
     {'nombre': 'Impresora', 'precio': 125, 'fecha_venta': '2020/12/22'}
2020/12/23
     {'nombre': 'Smartphone', 'precio': 235, 'fecha_venta': '2020/12/23'}
2020/12/27
     {'nombre': 'Scanner', 'precio': 95, 'fecha_venta': '2020/12/27'}
2020/12/29
     {'nombre': 'Altavoces', 'precio': 95, 'fecha_venta': '2020/12/29'}

Filtrar los elementos de una secuencia

numeros = [5,4,-6,3,-9,8,0,12]

print (numeros)

numeros_positivos = [n for n in numeros if n > 0 ]

print (numeros_positivos)

Última actualización: 2022-10-22