Parte 1 - Modulo 3:

Valores booleanos, ejecución condicional,

bucles, listas y su procesamiento.
PCAP - Programming Essentials in Python
Orientación complementaria
• A continuación se presentan orientaciones complementarias para el
desarrollo del tercer modulo de la primera parte del curso “PCAP -
Programming Essentials in Python” para dar aclaraciones necesarias para el
desarrollo del modulo en el contexto de CISCO NetAcad UNIVALLE

2
Contenido del Módulo
• En este módulo se estudia:
• Datos de tipo booleano.
• Operadores relacionales.
• Cómo tomar decisiones en Python (if, if-else, if-elif, else).
• Cómo repetir la ejecución de código usando los bucles (while, for).
• Cómo realizar operaciones lógicas y de bit a bit en Python.
• Listas en Python (construcción, indexación y segmentación; manipulación de
contenido).
• Cómo ordenar una lista usando algoritmos de clasificación de burbujas.
• Listas multidimensionales y sus aplicaciones.

3
Datos Booleanos o Lógicos
• Este tipo de dato está definido para responder interrogantes con dos
alternativas de respuesta
• True (Verdadero)
• False (Falso)
• Principalmente se utilizan en la construcciones de expresiones lógicas o
condiciones, las cuales permitirán controlar el flujo de ejecución de un
programa con Estructuras Decisionales y el bucle While.
• En Python el valor de False se asocia con 0 y el valor de True con 1.

4
Operadores Relacionales
• Son operadores empleados para la creación de expresiones lógicas o
condiciones.
• Comparan los valores almacenados en variables y retornan un valor True o
False de acuerdo a la relación que exista entre los valores comparados.
• Como operadores se deben considerar que los operadores relacionales
tienen una prioridad más baja que lo operadores aritméticos, por esto es
aconsejable escribir las condiciones entre paréntesis.

5
Operadores Relacionales
Operación Operador Sintáxis
var == 123
Comparación por igualdad ==
var1 == var2
var != 321
Comparación por desigualdad !=
var1 == var2
var > 3.0
Mayor que >
var1 > var2
var >= 31
Mayor o igual que >=
var1 >= var2
var < 26
Menor que <
var1 < var2
var <= 97
Menor o igual que <=
var1 <= var2

6
Laboratorio 1 – Preguntas y respuestas
• Tiempo Estimado: 5 minutos Nivel de Dificultad: Muy fácil
• Objetivos
• Familiarizarse con la función input().
• Familiarizarse con los operadores de comparación en Python
• Escenario
• Usando uno de los operadores de comparación en Python, escribe un programa
simple de dos líneas que tome el parámetro n como entrada, que es un entero, e
imprime False si n es menor que 100, y True si n es mayor o igual que 100.
• No debes crear ningún bloque if (hablaremos de ellos muy pronto). Prueba tu código
usando los datos que te proporcionamos..

7
Condiciones y ejecución condicional
• En Python se pueden utilizar las siguientes estructuras condicionales que
controlan el flujo de ejecución de los programas utilizando expresiones lógica
o condiciones.
• if <condición>: • if <condición_1>:
<bloque_if> <bloque_if>
elif <condición_2>:
• if <condición>: <bloque_elif>
<bloque_if> else:
else: <bloque_else>
<bloque_else>

8
IMPORTANTE: En Python los espacios cuentan…!
• Una de las principales características de Python es que los
espacios de tabulación son utilizados para definir los bloques
de varias instrucción en la definición de:
• Bloques de instrucciones de las estructuras condicionales
• Bloques de instrucciones de los bucles
• Definición de funciones de programador
• Si se emplean mal las sangrías de tabulación Python generará
errores en la sintaxis de escritura de las instrucciones

9
Sentencia bien tabulada: Sentencia mal tabulada:

if <condición_1>: if <condición_1>:
<bloque_if_i1> <bloque_if>
<bloque_if_i2> elif <condición_2>:
elif <condición_2>: <bloque_elif>
<bloque_elif> else:
else: <bloque_else>
<bloque_else>

10
Sentencia condicional: if
• Esta sentencia condicional consta de los siguientes elementos, estrictamente
necesarios en este orden:
• La palabra clave reservada if.
• Uno o más espacios en blanco.
• Una expresión lógica o condición
• Unos dos puntos seguido de una nueva línea.
• Una instrucción con sangría o un conjunto de instrucciones (se requiere absolutamente al
menos una instrucción); la sangría se puede lograr de dos maneras: insertando un número
particular de espacios (la recomendación es usar cuatro espacios de sangría), o usando el
tabulador; nota: si hay mas de una instrucción en la parte con sangría, la sangría debe ser la
misma en todas las líneas; aunque puede parecer lo mismo si se mezclan tabuladores con
espacios, es importante que todas las sangrías sean exactamente iguales Python 3 no permite
mezclar espacios y tabuladores para la sangría.

11
Sentencia condicional: if-else
• Esta sentencia se genera al añadir a la sentencia if la sentencia else: y su
respectivo bloque de instrucciones, que se ejecutará si no se cumple la
condición especificada por el if.
• La sentencia else: se refiere al if que se encuentra en el mismo nivel de
sangría
if <condición>:
<bloque_if>
else:
<bloque_else>

12
Sentencias condicionales anidadas
• Un if anidado es un sentencia if if <condición_1>:
que esta dentro del bloque de <bloque_if>
instrucciones de otro if o de su if <condición_2>:
else. <bloque_if_anidado>
<bloque_if_anidado>
• Para anidar un if se deberá
<bloque_if>
utilizar las sangrías de tabulación else:
para establecer y diferencias que <bloque_else>
instrucciones pertenecen al if
anidado y cuales no.

13
Sentencia condicional: if-elif-else
if <condición_1>:
• El elif es una sentencia es especial <bloque_C1>
en Python. Es una forma resumida #Se ejecuta el bloque si se cumple C1
de establecer un anidamiento else- elif <condición_2>:
<bloque_C2>
if. #No se cumple C1
• elif se usa para verificar más de #Se ejecuta el bloque si se cumple C2
elif <condición_3>:
una condición, y para detener <bloque_C3>
cuando se encuentra la primera #No se cumple C1, ni C2
sentencia verdadera. #Se ejecuta el bloque si se cumple C3
else:
<bloque_else>
#No se cumple C1, ni C2, ni C3

14
Laboratorio 2 – Operadores de comparación y ejecución condicional
• Tiempo Estimado: 5 - 10 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizarse con la función input().
• Familiarizarse con los operadores de comparación en Python.
• Familiarizarse con el concepto de ejecución condicional.
• Escenario
• Espatifilo, más comúnmente conocida como la planta de cuna de Moisés o flor de la paz, es
una de las plantas para interiores más populares que filtra las toxinas dañinas del aire. Algunas
de las toxinas que neutraliza incluyen benceno, formaldehído y amoníaco.
• Imagina que tu programa de computadora ama estas plantas. Cada vez que recibe una
entrada en forma de la palabra Espatifilo, grita involuntariamente a la consola la siguiente
cadena: "¡Espatifilo es la mejor planta de todas!"

15
Laboratorio 2 – Operadores de comparación y ejecución condicional
• Escenario
• Escribe un programa que utilice el concepto de ejecución condicional,
tome una cadena como entrada y que:
• Imprima el enunciado "Si, ¡El ESPATIFILIO! es la mejor planta de todos los
tiempos!" en la pantalla si la cadena ingresada es "ESPATIFILIO".
• Imprima "No, ¡quiero un gran ESPATIFILIO!" si la cadena ingresada es
"espatifilo".
• Imprima "¡ESPATIFILIO!, ¡No [entrada]!" de lo contrario. Nota: [entrada] es la
cadena que se toma como entrada.

16
Laboratorio 3 – Fundamentos de la sentencia if-else
• Tiempo Estimado: 5 - 10 minutos Nivel de Dificultad: Fácil/Medio
• Objetivos
• Familiarizar al estudiante con:
• Utilizar la sentencia if-else para ramificar la ruta de control.
• Construir un programa completo que resuelva problemas simples de la vida real.
• Escenario
• Érase una vez una tierra de leche y miel, habitada por gente feliz y próspera. La gente pagaba impuestos, por
supuesto, su felicidad tenía límites. El impuesto más importante, denominado Impuesto Personal de Ingresos
(IPI, para abreviar) tenía que pagarse una vez al año y se evaluó utilizando la siguiente regla:
• Si el ingreso del ciudadano no era superior a 85,528 pesos, el impuesto era igual al 18% del ingreso
menos 556 pesos y 2 centavos (esta fue la llamada exención fiscal ).
• Si el ingreso era superior a esta cantidad, el impuesto era igual a 14,839 pesos y 2 centavos, más el
32% del excedente sobre 85,528 pesos.

17
Laboratorio 3 – Fundamentos de la sentencia if-else
• Escenario
• Tu tarea es escribir una calculadora de impuestos.
• Debe aceptar un valor de punto flotante: el ingreso.
• A continuación, debe imprimir el impuesto calculado, redondeado a pesos totales. Hay una función
llamada round() que hará el redondeo por ti, la encontrarás en el código de esqueleto del editor.
CODIGO EN PANTALLA:
income = float(input("Introduce el ingreso anual:"))
#
# Escribe tu código aquí.
#
tax = round(tax, 0)
print("El impuesto es:", tax, "pesos")

18
Laboratorio 4 – Fundamentos de la sentencia if-elif-else
• Tiempo Estimado: 5 - 10 minutos Nivel de Dificultad: Fácil/Medio
• Objetivos
• Familiarizar al estudiante con:
• Utilizar la sentencia if-elif-else.
• Encontrar la implementación adecuada de las reglas definidas verbalmente.
• Emplear el código de prueba empleando entradas y salidas de muestra.
• Escenario
• Como seguramente sabrás, debido a algunas razones astronómicas, el año pueden ser bisiesto o común. Los
primeros tienen una duración de 366 días, mientras que los últimos tienen una duración de 365 días.
• Desde la introducción del calendario Gregoriano (en 1582), se utiliza la siguiente regla para determinar el tipo de
año:

19
Laboratorio 4 – Fundamentos de la sentencia if-elif-else
• Escenario
• Si el número del año no es divisible entre cuatro, es un año común.
• De lo contrario, si el número del año no es divisible entre 100, es un año bisiesto.
• De lo contrario, si el número del año no es divisible entre 400, es un año común.
• De lo contrario, es un año bisiesto.
• Observa el código en el editor: solo lee un número de año y debe completarse con las instrucciones que
implementan la prueba que acabamos de describir.
• El código debe mostrar uno de los dos mensajes posibles, que son Año Bisiesto o Año Común, según el valor
ingresado. Sería bueno verificar si el año ingresado cae en la era Gregoriana y emitir una advertencia de lo
contrario: No dentro del período del calendario Gregoriano. Consejo: utiliza los operadores != y %.
CODIGO EN PANTALLA:
year = int(input("Introduce un año:"))
#
# Escribe tu código aquí.
#

20
Bucle: while
• El bucle while repite la ejecución de un bloque de instrucciones siempre que
la condición que evalúa sea True.
• Si deseas ejecutar más de una sentencia dentro de un while, debes poner
sangría a todas las instrucciones de la misma manera.
• Una instrucción o conjunto de instrucciones ejecutadas dentro del while se
llama el cuerpo del bucle.
• Si la condición es False tan pronto como se compruebe por primera vez, el
cuerpo no se ejecuta ni una sola vez.
• El cuerpo debe poder cambiar el valor de la condición, porque si la condición
es True al principio, el cuerpo podría funcionar continuamente hasta el infinito.

21
Ejemplos de while
while (var>0):
# hacer_algo()
pass print (“Los números pares menores a 100 son:”)
j = 100
while (j>1):
j = j -2
j = 10
print(i)
while (j>0) :
print(j)
j -=1

22
Bucle infinito o loop
• Un bucle infinito, también denominado loop, es una secuencia de instrucciones en un
programa que se repite indefinidamente (bucle sin fin).
• Este es un ejemplo de un bucle que no puede finalizar su ejecución:
while True:
print("Estoy atrapado dentro de un bucle.")
• Este bucle imprimirá infinitamente "Estoy atrapado dentro de un bucle". En la pantalla.
• Como dijimos el cuerpo del bucle while debe poder cambiar el valor de la condición,
porque si la condición es True al principio, el cuerpo se repetiría hasta el infinito.

23
Laboratorio 5 – Adivina el número secreto
• Tiempo Estimado: 15 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizar al estudiante con:
• Utilizar el bucle while.
• Reflejar situaciones de la vida real en código de computadora.
• Escenario
• Un mago junior ha elegido un número secreto. Lo ha escondido en una variable llamada secret_number.
Quiere que todos los que ejecutan su programa jueguen el juego Adivina el número secreto, y adivina
qué número ha elegido para ellos. ¡Quiénes no adivinen el número quedarán atrapados en un bucle sin
fin para siempre! Desafortunadamente, él no sabe cómo completar el código.

24
Laboratorio 5 – Adivina el número secreto
• Escenario
• Tu tarea es ayudar al mago a completar el código en el editor de tal manera que el código:
• Pedirá al usuario que ingrese un número entero.
• Utilizará un bucle while.
• Comprobará si el número ingresado por el usuario es el mismo que el número escogido por el
mago. Si el número elegido por el usuario es diferente al número secreto del mago, el usuario
debería ver el mensaje "¡Ja, ja! ¡Estás atrapado en mi bucle!" y se le solicitará que ingrese un
número nuevamente. Si el número ingresado por el usuario coincide con el número escogido por el
mago, el número debe imprimirse en la pantalla, y el mago debe decir las siguientes palabras:
"¡Bien hecho, muggle! Eres libre ahora".

25
Bucle: for
• El bucle for puede "explorar" grandes colecciones de datos elemento por elemento,
utilizando una variable de control o contador que toma valores por la función range(inicio,
fin, incremento), que es un generador se series numéricas.
• La palabra reservada for abre el bucle for, no hay condición después de eso; no tienes
que pensar en las condiciones, ya que se verifican internamente, sin ninguna intervención.
• Cualquier variable después de la palabra reservada for es la variable de control del
bucle; cuenta los giros del bucle y lo hace automáticamente.
• La palabra reservada in introduce un elemento de sintaxis que describe el rango de
valores posibles que se asignan a la variable de control.
• La función range es una función especial de tipo generador, te la explicamos a
continuación.

26
Generador: range
• La función range es un generador de números enteros, que puede tener
hasta tres parámetros, pero como mínimo necesita un parámetro.
• range (fin): genera una serie de números enteros que comienza en 0 y termina en el
valor del parámetro fin-1, con incrementos de 1.
• range (inicio, fin): genera una serie de números enteros que comienza en el valor de
inicio y termina en el valor del parámetro fin-1, con incrementos de 1.
• range (inicio, fin, incremento): genera una serie de números enteros que comienza
en el valor de inicio y termina con el ultimo valor menor a fin, con incrementos
establecidos con el valor de incremento.
• Los parámetros inicio, fin e incremento deben ser enteros

27
Ejemplos de for
for i in range(100):
# hacer_algo()
pass print (“Los números pares menores a 2 son:”)
for i in range(2, 100, 2):
print(i)

for j in range (10, 20):

print(j)

28
Palabra reservada pass
• En muchos ejemplos del curso se utiliza la palabra reservada pass, para
crear bucles o condicionales que no hagan nada.
• La palabra clave pass dentro de un bloque de instrucciones no hace nada en
absoluto; es una instrucción vacía, la utilizamos porque la sintaxis del bucle
for exige al menos una instrucción dentro del cuerpo (por cierto, if, elif, else y
while requieren lo mismo).

29
Laboratorio 6 – Fundamentos del bucle for: el conteo
• Tiempo Estimado: 5 minutos Nivel de Dificultad: Muy fácil
• Objetivos
• Familiarizar al estudiante con:
• Utilizar el bucle for.
• Reflejar situaciones de la vida real en código de computadora.
• Escenario
• ¿Sabes lo que es Mississippi? Bueno, es el nombre de uno de los estados y ríos en los Estados Unidos. El río
Mississippi tiene aproximadamente 2,340 millas de largo, lo que lo convierte en el segundo río más largo de los
Estados Unidos (el más largo es el río Missouri). ¡Es tan largo que una sola gota de agua necesita 90 días para
recorrer toda su longitud!
• La palabra Mississippi también se usa para un propósito ligeramente diferente: para contar mississippily
(mississippimente).
• Si no estás familiarizado con la frase, estamos aquí para explicarte lo que significa: se utiliza para contar segundos.

30
Laboratorio 6 – Fundamentos del bucle for: el conteo
• Escenario
• La idea detrás de esto es que agregar la palabra Mississippi a un número al contar los segundos en voz alta hace
que suene más cercano al reloj, y por lo tanto "un Mississippi, dos Mississippi, tres Mississippi" tomará
aproximadamente unos tres segundos reales de tiempo. A menudo lo usan los niños que juegan al escondite para
asegurarse de que el buscador haga un conteo honesto.
• Tu tarea es muy simple aquí: escribe un programa que use un bucle for para "contar de forma mississippi" hasta
cinco. Habiendo contado hasta cinco, el programa debería imprimir en la pantalla el mensaje final "¡Listos o no, ahí
voy!"
• Utiliza el esqueleto que hemos proporcionado en el editor.}

CODIGO EN PANTALLA:
import time
# Escribe un bucle for que cuente hasta cinco.
# Cuerpo del bucle: imprime el número de iteración del bucle y la palabra "Mississippi".
# Cuerpo del bucle - usar: time.sleep (1)
# Escribe una función de impresión con el mensaje final.

31
La sentencia break y continue
• Con estas instrucciones se corta la ejecución de los bucles. En un buen
programa estructurado no debería se necesario, pero al utilizar facilitan las
tareas de programación por eso se las denominan dulces sintácticos o azúcar
sintáctica.
• 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.
32
Laboratorio 7 – La sentencia break - Atascado en un bucle
• Tiempo Estimado: 10 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizar al estudiante con:
• Utilizar la instrucción break en los bucles.
• Reflejar situaciones de la vida real en código de computadora.
• Escenario
• La instrucción break se implementa para salir/terminar un bucle.
• Diseña un programa que use un bucle while y le pida continuamente al usuario que ingrese una palabra a menos
que ingrese "chupacabra" como la palabra de salida secreta, en cuyo caso el mensaje "¡Has dejado el bucle con
éxito". Debe imprimirse en la pantalla y el bucle debe terminar.
• No imprimas ninguna de las palabras ingresadas por el usuario. Utiliza el concepto de ejecución condicional y la
sentencia break.

33
Laboratorio 8 – La sentencia continue - El Feo Devorador de Vocales
• Tiempo Estimado: 10-15 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizar al estudiante con:
• Utilizar la instrucción continue en los bucles
• Reflejar situaciones de la vida real en código de computadora.
• Escenario
• La sentencia continue se usa para omitir el bloque actual y avanzar a la siguiente iteración, sin ejecutar las
sentencias dentro del bucle. Se puede usar tanto con while y for.
• Tu tarea aquí es muy especial: ¡Debes diseñar un devorador de vocales! Escribe un programa que use:
• Un bucle for.
• El concepto de ejecución condicional (if-elif-else).
• La sentencia continue.

34
Laboratorio 8 – La sentencia continue - El Feo Devorador de Vocales
• Escenario
• Tu programa debe:
• Pedir al usuario que ingrese una palabra.
• Utiliza user_word = user_word.upper() para convertir la palabra ingresada por el usuario a mayúsculas;
hablaremos sobre los llamados métodos de cadena y el upper() muy pronto, no te preocupes.
• Utiliza la ejecución condicional y la instrucción continue para "comer" las siguientes vocales A , E , I , O ,
U de la palabra ingresada.
• Imprime las letras no consumidas en la pantalla, cada una de ellas en una línea separada.
CODIGO EN PANTALLA:
# Indicar al usuario que ingrese una palabra
# y asignarlo a la variable user_word.
for letter in user_word:
# Completa el cuerpo del bucle for.

35
Laboratorio 9 – La sentencia continue –
El Bonito Devorador de Vocales
• Tiempo Estimado: 5-10 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizar al estudiante con:
• Utilizar la instrucción continue en los bucles
• Modificar y actualizar el código existente.
• Reflejar situaciones de la vida real en código de computadora.
• Escenario
• Tu tarea aquí es aún más especial que antes: ¡Debes rediseñar el devorador de vocales (feo) del laboratorio
anterior (3.1.2.10) y crear un mejor devorador de vocales (bonito) mejorado! Escribe un programa que use:
• Un bucle for.
• El concepto de ejecución condicional (if-elif-else).
• La instrucción continue.

36
Laboratorio 9 – La sentencia continue
El Bonito Devorador de Vocales
• Escenario
• Tu programa debe:
• Pedir al usuario que ingrese una palabra.
• Utilizar user_word = user_word.upper() para convertir la palabra ingresada por el usuario a mayúsculas;
hablaremos sobre los llamados métodos de cadena y el upper() muy pronto, no te preocupes.
• Emplea la ejecución condicional y la instrucción continue para "comer" las siguientes vocales A , E , I , O , U
de la palabra ingresada.
• Asigne las letras no consumidas a la variable word_without_vowels e imprime la variable en la pantalla.
CODIGO EN PANTALLA
word_without_vowels = ""
# Indicar al usuario que ingrese una palabra
# y asignarla a la variable user_word.
for letter in user_word:
# Completa el cuerpo del bucle.
# Imprimir la palabra asignada a word_without_vowels.

37
La rama else: de los bucles
• Ambos bucles while y for, tienen una característica interesante, que rara vez
se usa, al concluir un bucle puede definirse un else.
• La rama else del bucle siempre se ejecuta una vez, independientemente de si
el bucle ha entrado o no en su cuerpo, se ejecuta al concluir el bucle.
i=1 i=0
while i < 5: for i in range(5):
print(i) print(i)
i += 1 else:
else: print("else:", i)
print("else:", i) Nota: En el for si la variable de control no existe antes de que comience
el bucle, no existirá cuando la ejecución llegue a la rama else.

38
Laboratorio 10 – Fundamentos del bucle while
• Tiempo Estimado: 20-30 minutos Nivel de Dificultad: Medio
• Objetivos
• Familiarizar al estudiante con:
• Utilizar el bucle while.
• Encontrar la implementación adecuada de reglas definidas verbalmente.
• Reflejar situaciones de la vida real en código de computadora.
• Escenario
• Escucha esta historia: Un niño y su padre, un programador de computadoras, juegan con bloques de madera.
Están construyendo una pirámide.
• Su pirámide es un poco rara, ya que en realidad es una pared en forma de pirámide, es plana. La pirámide se apila
de acuerdo con un principio simple: cada capa inferior contiene un bloque más que la capa superior.
• La figura ilustra la regla utilizada por los constructores:

39
Laboratorio 10 – Fundamentos del bucle while
• Escenario
• Tu tarea es escribir un programa que lea la cantidad de bloques que tienen los constructores, y generar la
altura de la pirámide que se puede construir utilizando estos bloques.
• Nota: La altura se mide por el número de capas completas: si los constructores no tienen la cantidad
suficiente de bloques y no pueden completar la siguiente capa, terminan su trabajo inmediatamente.
CODIGO EN PANTALLA:
blocks = int(input("Ingresa el número de bloques: "))
#
# Escribe tu código aquí.
#
print("La altura de la pirámide:", height)

40
Laboratorio 11 – Hipótesis de Collatz
• Tiempo Estimado: 20 minutos Nivel de Dificultad: Medio
• Objetivos
• Familiarizar al estudiante con:
• Utilizar el bucle while.
• Convertir bucles definidos verbalmente en código real de Python.
• Escenario
• En 1937, un matemático alemán llamado Lothar Collatz formuló una hipótesis intrigante (aún no se ha
comprobado) que se puede describir de la siguiente manera:
1. Toma cualquier número entero que no sea negativo y que no sea cero y asígnale el nombre c0.
2. Si es par, evalúa un nuevo c0 como c0 / 2.
3. De lo contrario, si es impar, evalúe un nuevo c0 como 3 * c0 + 1.
4. Si c0 no es 1, salta al punto 2.

41
Laboratorio 11 – Hipótesis de Collatz
• Escenario
• La hipótesis dice que, independientemente del valor inicial de c0, el valor siempre tiende a 1.
• Por supuesto, es una tarea extremadamente compleja usar una computadora para probar la hipótesis
de cualquier número natural (incluso puede requerir inteligencia artificial), pero puede usar Python para
verificar algunos números individuales. Tal vez incluso encuentres el que refutaría la hipótesis.
• Escribe un programa que lea un número natural y ejecute los pasos anteriores siempre que c0 sea
diferente de 1. También queremos que cuente los pasos necesarios para lograr el objetivo. Tu código
también debe mostrar todos los valores intermedios de c0.
• Sugerencia: la parte más importante del problema es como transformar la idea de Collatz en un bucle
while- esta es la clave del éxito.

42
Operadores y expresiones lógicas
• En Python existen operadores lógicos que permiten combinar condiciones
simples para crear una condición compuesta y mas compleja. Esta ultima
condición se denomina también expresión lógica.
• En Python existen tres operadores lógicos, equivalentes a los operadores de
la lógica matemática
• and (Conjunción lógica – y lógico)
• or (Disyunción lógica – o lógico)
• not (Negación lógica)

43
Operador lógico: and
• Un operador de conjunción lógica en Python es la palabra and. Es un operador binario
con una prioridad inferior a la expresada por los operadores de comparación.
counter > 0 and value == 100
• El resultado proporcionado por el operador and se puede determinar sobre la base de la
tabla de verdad.
Argumento A Argumento B A and B
False False False
False True False
True False False
True True True

44
Operador lógico: or
• Un operador de disyunción lógica en Python es la palabra or. Es un operador binario con
una prioridad más baja que and.
counter > 0 or value == 100
• El resultado proporcionado por el operador or se puede determinar sobre la base de la
tabla de verdad.
Argumento A Argumento B A or B
False False False
False True True
True False True
True True True

45
Operador lógico: 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
• Este operador se escribe como la palabra not, y su prioridad es muy alta, igual que el
unario + y -. Su tabla de verdad es simple:

Argumento A not A
False True
True False

46
Representación binaria de los datos
• Como estudiamos en la Universidad, los datos que maneja la computadora se almacenan
en su memoria en forma binaria, utilizando 32 o 64 bits.
i = 15  i: 00000000000000000000000000001111
j = 22  j: 00000000000000000000000000010110
• En Python a estas representaciones binarias se les puede asignar un valor lógico y
existen operadores que permiten operar bit a bit estas representaciones.

47
El valor lógico de las representaciones binarias
• Los operadores lógicos al trabajar con las representaciones binarias solo
conocen el valor cero (cuando todos los bits se restablecen) que significa
False, y el valor no cero (cuando se establece al menos un bit) que significa
True. Es así que podemos operar cualquier tipo de dato con los operadores
lógicos
i=0
j = 13
print (not i)  True
Print (not j)  False

48
Operadores bit a bit
• En Python hay cuatro operadores que le permiten manipular bits de datos
individuales. Se denominan operadores bit a bit.
• & (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).

49
Operador bit a bit
• Cuando se operan individualmente los bits se utiliza la siguiente tabla de
verdad:

Argumento A Argumento B A&B A|B A^B ~A

0 0 0 0 0 1
0 1 0 1 1
1 0 0 1 1 0
1 1 1 1 0

50
Desplazamiento binario
• Python ofrece otra operación relacionada con los bits individuales: shifting o
desplazamiento binario. Esto se aplica solo a los valores de número entero, y
no debe usar flotantes como argumentos para ello.
• El desplazamiento recorre a la izquierda o la derecha la representación
binaria una cantidad de i bits, asignando a los nuevos bits un valor 0.
• Desplazamiento izquierda: var << i equivale a var * 2i
• Desplazamiento derecha: var >>i equivale a var // 2i

51
Listas en Python
• En la mayoría de las aplicaciones informáticas se requiere almacenar una gran cantidad
de datos bajo un único identificador, es por eso que surgen las estructuras de datos.
• En Python las Listas son las estructura de datos más utilizada.
• Una Lista almacena bajo un mismo identificador un conjunto de datos que pueden ser de
diferente tipo, las listas en Python pueden almacenar solo números, o números y cadenas
mezcladas.
• Para utilizar cada dato individual, en un principio, se accede a éste mediante su posición
secuencial en el conjunto al momento de ser creada la lista o índice.

52
Ejemplo de listas enteros[2]: 7

enteros = [ 10, 5, 7, 2, 1]
Índices: 0, 1, 2, 3, 4
Tamaño de la lista:
len (enteros)  5

Diferentes = [‘a’, 123, 0.34, “hola”, 452, ‘c’, 3]

len (diferentes)  7

53
Función len()
• La longitud de una lista puede variar durante la ejecución. Se pueden agregar
nuevos elementos a la lista, mientras que otros pueden eliminarse de ella.
Esto significa que la lista es una entidad muy dinámica.
• Si deseas verificar la longitud actual de la lista, puedes usar una función
llamada len() (su nombre proviene de length - longitud).
• La función toma el nombre de la lista como un argumento y devuelve el
número de elementos almacenados actualmente dentro de la lista (en otras
palabras, la longitud de la lista).

54
Eliminando elementos de la lista
• Cualquier elemento de la lista puede ser eliminado en cualquier momento,
esto se hace con una instrucción llamada del (eliminar).
• Tienes que apuntar al elemento que quieres eliminar, desaparecerá de la lista
y la longitud de la lista se reducirá en uno.
• La posición del dato eliminado tomara el valor del dato que le seguía en la
lista, y todos los demás datos se recorrerán a una posición anterior en el
orden de los índices, eliminando la última posición de la lista original
del lista[posición]
del enteros[2]

55
Índices negativos en las listas
• En Python las listas pueden utilizar números negativos como índice para
hacer referencia a un dato almacenado en esa lista.
• Los índices positivos se numeran de izquierda a derecha empezando desde 0
al principio de la lista, incrementándose en 1, y el índice de la ultima posición
tendrá el valor de len(lista)-1.
• Los índices negativos se numeran de derecha a izquierda, empezando desde
-1 al final de la lista, decrementado en 1, y el índice de la primera posición de
la lista tendrá el valor de –len(lista)

56
Índices negativos y positivos de las listas
enteros = [ 3, 5, 7, 2, 1] Tamaño de la lista:
Índices positivos: 0, 1, 2, 3, 4 len (enteros)  5
Índices positivos: -5, -4, -3, -2, -1

enteros[1]  5
enteros[4]  1

enteros[-2]  2
Enteros[-5]  3

57
Laboratorio 12 – Lo básico de las listas
• Tiempo Estimado: 5 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizar al estudiante con:
• Usar instrucciones básicas relacionadas con listas.
• Crear y modificar listas.
• Escenario
• Había una vez un sombrero. El sombrero no contenía conejo, sino una lista de cinco números: 1, 2, 3, 4 y 5.
• Tu tarea es:
• Escribir una línea de código que solicite al usuario que reemplace el número central en la lista con un número
entero ingresado por el usuario (Paso 1).
• Escribir una línea de código que elimine el último elemento de la lista (Paso 2).
• Escribir una línea de código que imprima la longitud de la lista existente (Paso 3).

58
Laboratorio 12 – Lo básico de las listas
• Escenario
CODIGO EN PANTALLA
hat_list = [1, 2, 3, 4, 5] # Esta es una lista existente de números ocultos en el sombrero.
# Paso 1: escribe una línea de código que solicite al usuario
# reemplazar el número de en medio con un número entero ingresado por el usuario.
# Paso 2: escribe aquí una línea de código que elimine el último elemento de la lista.
# Paso 3: escribe aquí una línea de código que imprima la longitud de la lista existente.

print(hat_list)

59
Métodos de una lista
• Una lista se puede crear de manera que este vacía, para luego añadirle elementos:
lista = [ ]
• Los método propios de las listas son:
• lista.append(dato): Un nuevo elemento puede ser añadido al final de la lista
existente.
• lista.insert(posición, dato): El método insert() es un poco más inteligente: puede
agregar un nuevo elemento en cualquier lugar de la lista, no solo al final.

60
Intercambio de valores en Python
• En otros lenguajes de programación para intercambiar los valores entre dos o más
variables se necesita de una variable auxiliar:
variable_1 = 1
variable_2 = 2
auxiliar = variable_1
variable_1 = variable_2
variable_2 = auxiliar
• Python ofrece una forma más conveniente de hacer el intercambio, echa un vistazo:
variable_1 = 1
variable_2 = 2
variable_1, variable_2 = variable_2, variable_1

61
Laboratorio 13 – Beatles
• Tiempo Estimado: 10-15 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizar al estudiante con:
• Crear y modificar listas simples.
• Utilizar métodos para modificar listas.
• Escenario
• Los Beatles fueron uno de los grupos de música más populares de la década de 1960 y la banda más
vendida en la historia. Algunas personas los consideran el acto más influyente de la era del rock. De
hecho, se incluyeron en la compilación de la revista Time de las 100 personas más influyentes del siglo
XX.
• a banda sufrió muchos cambios de formación, que culminaron en 1962 con la formación de John
Lennon, Paul McCartney, George Harrison y Richard Starkey (mejor conocido como Ringo Starr).

62
Laboratorio 13 – Beatles
• Escenario
• Escribe un programa que refleje estos cambios y le permita practicar con el concepto de listas. Tu tarea
es:
• Paso 1: Crea una lista vacía llamada beatles.
• Paso 2: Emplea el método append() para agregar los siguientes miembros de la banda a la lista:
John Lennon, Paul McCartney y George Harrison.
• Paso 3: Emplea el buclefor y el append() para pedirle al usuario que agregue los siguientes
miembros de la banda a la lista: Stu Sutcliffe, y Pete Best.
• Paso 4: Usa la instrucción del para eliminar a Stu Sutcliffe y Pete Best de la lista.
• Paso 5: Usa el método insert() para agregar a Ringo Starr al principio de la lista.

63
Otros métodos de las listas
• Las listas en Python tienen métodos que realizan tareas como ordenar su
contenido, ahorrando bastante trabajo de programación.
• lista.sort(): Ordena los elemento de manera ascendente
• Otro método de las listas en Python permite invertir el orden en el que se
encuentran los elementos en la lista
• lista.reverse(): Inverte el orden de los elementos de la lista
• Para ordenar de manera descendente tendríamos que hacer los siguiente:
lista.sort()
lista.reverse()

64
Las lista son referencia de memoria
• En Python debemos considerar que:
• El nombre de una variable ordinaria es el nombre de su contenido.
• El nombre de una lista es el nombre de una ubicación de memoria donde se almacena la lista.
• Una asignación: list_2 = list_1 copia la referencia no su contenido. En efecto, los dos
nombres (list_1 y list_2) identifican la misma ubicación en la memoria de la
computadora. Modificar una lista afecta a la otra, y viceversa. En términos sencillos
son la misma lista.

65
Rebanadas de una lista
• Una rebanada es un elemento de la sintaxis de Python que permite hacer una
copia nueva de una lista, o partes de una lista. En realidad, copia el contenido
de la lista, no el nombre de la lista.
• Una de las formas más generales de la rebanada es la siguiente:
rebanada_lista[inicio:fin]
• Una rebanada crea una nueva lista (de destino), tomando elementos de la
lista de origen: los elementos de los índices desde el principio con el inicio=0
hasta el fin – 1, donde fin es la longitud de la lista como máximo.

66
Características de las rebanadas (slices)
• Si tenemos lista =[‘a’, ‘e’, ‘i’, ‘o’, ‘u’] con las rebanadas podemos realizar lo siguientes:
• Copiar todo el contenido a una nueva lista: lista_nueva = lista[ : ]
• Copiar desde el principio hasta una posición final: lista_nueva = lista[ :3]
• Copiar desde una posición de inicio hasta el final: lista_nueva = lista[2: ]
• Copiar un rango concreto de índices positivos:
lista_nueva = lista[1:3]
• Se pueden utilizar índices negativos:
lista_nueva = lista[-4:-2]

67
Los operadores in y not in
• Python ofrece dos operadores muy poderosos, capaces de revisar la lista para verificar si
un valor específico está almacenado dentro de la lista o no.
• Estos operadores son:
• elemento in mi_lista
• elemento not in mi_lista
• El primero de ellos (in) verifica si un elemento dado está actualmente almacenado en
algún lugar dentro de la lista - el operador devuelve True en este caso.
• El segundo (not in) comprueba si un elemento dado NO está en una lista - el operador
devuelve True en este caso.

68
Recorrer los elementos de una lista
• Con el operador in y el bucle for se puede recorrer uno por uno los
elementos de una lista de izquierda a derecha.

lista = [“Adrián”, “Beatriz”, “Carlos”, “Daniela”, “Elias”]

for nombre in lista:
print(“Hola..” + nombre)

69
Laboratorio 14 – Operando con listas
• Tiempo Estimado: 10-15 minutos Nivel de Dificultad: Fácil
• Objetivos
• Familiarizar al estudiante con:
• Indexación de listas.
• Utilizar operadoresin y not in.
• Escenario
• Imagina una lista: no muy larga ni muy complicada, solo una lista simple que contiene algunos números
enteros. Algunos de estos números pueden estar repetidos, y esta es la clave. No queremos ninguna
repetición. Queremos que sean eliminados.
• Tu tarea es escribir un programa que elimine todas las repeticiones de números de la lista. El objetivo
es tener una lista en la que todos los números aparezcan no más de una vez.

70
Laboratorio 14 – Operando con listas
• Escenario
CODIGO EN PANTALLA:
my_list = [1, 2, 4, 4, 1, 4, 2, 6, 2, 9]
#
# Escribe tu código aquí.
#
print("La lista con elementos únicos:")
print(my_list)

71
Listas dentro de listas
• Las listas pueden constar de escalares (es decir, números) y elementos de una estructura
mucho más compleja como cadenas, booleanos o inclusive otras listas.
• A menudo encontramos estos arreglos en nuestras vidas. Probablemente el mejor ejemplo
de esto sea un tablero de ajedrez.
• IMPORTANTE: Como hemos visto hasta ahora en Python no existe el concepto de vector,
ni el de matriz, la equivalencia más cercana que podemos definir es:
• Vector = lista
• Matriz = lista de listas
• Para trabajar a nivel matemático con vectores y matrices se utilizan las listas para
crear arreglos con el paquete de Python denominado numpy

72
Ejemplo de lista de listas
fila1 = [1, 2, 3]
fila2 = [4, 5, 6]
fila3 = [7, 8, 9]
lista_de_listas = [fila1, fila2, fila3]

• Gracias a esta forma de trabajar de las listas se podrá trabajar con arreglos
multidimensionales.

73
Listas por comprensión
• Es posible crear lista en tiempo de ejecución del código, tomado una patrón o
formula de creación. Esta forma de creación de lista se denomina por
comprensión:
lista = [ x for x in range (5)]  [0, 1, 2, 3, 4]
lista = [ 2**x for x in range (1,4)]  [2, 4, 8, 16]
matriz = [ [ i+j for i in range(4)] for j in range (4)]  [ [ 0, 1, 2, 3 ],
[ 1, 2, 3, 4 ],
[ 2, 3, 4, 5 ],
[ 3, 4, 5, 6 ] ]

74