3.

1 Sección 1 – Toma de
decisiones en Python

Deslizar para comenzar 

¡Bienvenido al Módulo 3! En la primera sección, aprenderemos sobre las sentencias

condicionales y cómo usarlas para tomar decisiones en Python.
3.1.1 Preguntas y Respuestas

Un programador escribe un programa y el programa hace preguntas.

Una computadora ejecuta el programa y proporciona las respuestas. El programa debe

ser capaz de reaccionar de acuerdo con las respuestas recibidas.

Afortunadamente, las computadoras solo conocen dos tipos de respuestas:

Si, es cierto.
No, esto es falso.

Nunca obtendrás una respuesta como Déjame pensar...., no lo sé, o probablemente sí,
pero no lo sé con seguridad.

Para hacer preguntas, Python utiliza un conjunto de operadores muy especiales.

Revisemos uno tras otro, ilustrando sus efectos en algunos ejemplos simples.

3.1.2 Comparación: operador de

igualdad
 Pregunta: ¿son dos valores iguales?

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

No olvides esta importante distinción:

= es un operador de asignación, por ejemplo, a = b asigna a la varable a el

valor de b ;
== es una pregunta ¿Son estos valores iguales? así que a == b compara a y b .

Es un operador binario con enlazado del lado izquierdo. Necesita dos argumentos y
verifica si son iguales.

3.1.3 Ejercicios

Ahora vamos a hacer algunas preguntas. Intenta adivinar las respuestas.

Pregunta #1: ¿Cuál es el resultado de la siguiente comparación?

2 == 2

Revisar

Pregunta #2: ¿Cuál es el resultado de la siguiente comparación?

 2 == 2.

Revisar

Pregunta #3: ¿Cuál es el resultado de la siguiente comparación?

1 == 2

Revisar

3.1.4 Operadores

Igualdad: El operador igual a (==)

El operador == (igual a) 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 .

Observa la comparación de igualdad a continuación - ¿Cuál es el resultado de esta

operación?

var == 0
 Toma en cuenta que no podemos encontrar la respuesta si no sabemos qué valor está
almacenado actualmente en la variable var .

Si la variable se ha cambiado muchas veces durante la ejecución del programa, o si se

ingresa su valor inicial desde la consola, Python solo puede responder a esta pregunta
en el tiempo de ejecución del programa.

Ahora imagina a un programador que sufre de insomnio, y tiene que contar las ovejas
negras y blancas por separado siempre y cuando haya exactamente el doble de ovejas
negras que de las blancas.

La pregunta será la siguiente:

black_sheep == 2 * white_sheep

Debido a la baja prioridad del operador == , la pregunta será tratada como la siguiente:

black_sheep == (2 * white_sheep)

Entonces, vamos a practicar la comprensión del operador == - ¿puedes adivinar la

output del código a continuación?

  

1 var = 0 # Asignando 0 a var

2 print(var == 0)
3
4 var = 1 # Asignando 1 a var
5 print(var == 0)
6
 Console  

Ejecuta el código y comprueba si tenías razón.

Desigualdad: el operador no es igual a (!=)

El operador != (no es igual a) también compara los valores de dos operandos. Aquí está
la diferencia: si son iguales, el resultado de la comparación es False . Si no son iguales,
el resultado de la comparación es True .

Ahora echa un vistazo a la comparación de desigualdad a continuación - ¿puedes

adivinar el resultado de esta operación?

var = 0 # Asignando 0 a var

print(var != 0)

var = 1 # Asignando 1 a var

print(var != 0)

Ejecuta el código y comprueba si tenías razón.

Operadores de comparación: mayor que

También se puede hacer una pregunta de comparación usando el operador > (mayor
que).

Si deseas saber si hay más ovejas negras que blancas, puedes escribirlo de la siguiente
manera:
black_sheep > white_sheep # Mayor que

True lo confirma; False lo niega.

Operadores de comparación: mayor o igual que

El operador mayor que tiene otra variante especial, una variante no estricta, pero se
denota de manera diferente que la notación aritmética clásica: >= (mayor o igual que).

Hay dos signos subsecuentes, no uno.

Ambos operadores (estrictos y no estrictos), así como los otros dos que se analizan en
la siguiente sección, son operadores binarios con enlazado del lado izquierdo, y su
prioridad es mayor que la mostrada por == y != .

Si queremos saber si tenemos que usar un gorro o no, nos hacemos la siguiente
pregunta:

centigrade_outside >= 0.0 # Mayor o igual que

Operadores de comparación: menor o igual que

Como probablemente ya hayas adivinado, los operadores utilizados en este caso son: El
operador < (menor que) y su hermano no estricto: <= (menor o igual que).

Observa este ejemplo simple:

current_velocity_mph < 85 # Menor que

current_velocity_mph <= 85 # Menor o igual que
 Vamos a comprobar si existe un riesgo de ser multados por la ley (la primera pregunta es
estricta, la segunda no).

3.1.5 Haciendo uso de las respuestas

¿Qué puedes hacer con la respuesta (es decir, el resultado de una operación de
comparación) que se obtiene de la computadora?

Existen al menos dos posibilidades: primero, puedes memorizarlo (almacenarlo en una

variable) y utilizarlo más tarde. ¿Cómo haces eso? Bueno, utilizarías una variable
arbitraria como esta:

answer = number_of_lions >= number_of_lionesses

El contenido de la variable te dirá la respuesta a la pregunta.

La segunda posibilidad es más conveniente y mucho más común: puedes utilizar la

respuesta que obtengas para tomar una decisión sobre el futuro del programa.

Necesitas una instrucción especial para este propósito, y la discutiremos muy pronto.

Ahora necesitamos actualizar nuestra tabla de prioridades, y poner todos los nuevos
operadores en ella. Ahora se ve como a continuación:
 Prioridad Operador

1 + , - unario

2 **

3 * , / , // , %

4 + , - binario

5 < , <= , > , >=

6 == , !=

LAB

3.1.6 LAB Variables ‒ Preguntas y

Respuestas

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 if 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.

Datos de Prueba

Entrada de muestra: Salida esperada:

Output
55
False

Entrada de muestra: Salida esperada:

Output
99
False

Entrada de muestra: Salida esperada:

Output
100
True

Entrada de muestra: Salida esperada:

Output
101
True

Entrada de muestra: Salida esperada:

Output
-5
False
 Entrada de muestra: Salida esperada:

Output
+123
True

  

Console  

Solución de muestra
 3.1.7 Condiciones y ejecución
condicional

Ya sabes como hacer preguntas a Python, pero aún no sabes como hacer un uso
razonable de las respuestas. Se debe tener un mecanismo que le permita hacer algo si
se cumple una condición, y no hacerlo si no se cumple.

Es como en la vida real: haces ciertas cosas o no cuando se cumple una condición
específica, por ejemplo, sales a caminar si el clima es bueno, o te quedas en casa si está
húmedo y frío.

Para tomar tales decisiones, Python ofrece una instrucción especial. Debido a su
naturaleza y su aplicación, se denomina instrucción condicional (o sentencia
condicional).

Existen varias variantes de la misma. Comenzaremos con la más simple, aumentando la

dificultad lentamente.

La primera forma de una sentencia condicional, que puede ver a continuación, está
escrita de manera muy informal pero figurada:

if true_or_not:
do_this_if_true

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 (una pregunta o una respuesta) cuyo valor se interpretar únicamente
en términos de True (cuando su valor no sea cero) y False (cuando sea igual a
cero);
Unos dos puntos seguidos de una nuevalí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.

¿Cómo funciona esta sentencia?

Si la expresión true_or_not representa la verdad (es decir, su valor no es igual a

cero), las sentencias con sangría se ejecutarán;
Si la expresión true_or_not no representa la verdad (es decir, su valor es igual a
cero), las sentencias con sangría se omitirán (ignorado), y la siguiente instrucción
ejecutada será la siguiente al nivel de la sangría original.

En la vida real, a menudo expresamos un deseo:

si el clima es bueno, saldremos a caminar

después, almorzaremos

Como puedes ver, almorzar no es una actividad condicional y no depende del clima.

Sabiendo que condiciones influyen en nuestro comportamiento y asumiendo que

tenemos las funciones sin parámetros go_for_a_walk() y have_lunch() , podemos escribir
el siguiente fragmento de código:

1 if the_weather_is_good:
2 go_for_a_walk()
3 have_lunch()
4

Ejecución condicional: la sentencia if

Si un determinado desarrollador de Python sin dormir se queda dormido cuando cuenta
120 ovejas, y el procedimiento de inducción del sueño se puede implementar como una
función especial llamada sleep_and_dream() , el código toma la siguiente forma:
1 if sheep_counter >= 120: # Evaluar una expresión condicional
2 sleep_and_dream() # Ejecutar si la expresión condicional es verdadera
3

Puedes leerlo como sigue: si sheep_counter es mayor o igual que 120 , entonces duerme
y sueña (es decir, ejecuta la función sleep_and_dream ).

Hemos dicho que las sentencias condicionales deben tener sangría. Esto crea una
estructura muy legible, demostrando claramente todas las rutas de ejecución posibles en
el código.

Analiza el siguiente código:

1 if sheep_counter >= 120:

2 make_a_bed()
3 take_a_shower()
4 sleep_and_dream()
5 feed_the_sheepdogs()
6

Como puedes ver, tender la cama, tomar una ducha y dormir y soñar se ejecutan
condicionalmente - cuando sheep_counter alcanza el límite deseado.

Alimentar a los perros, sin embargo, siempre se hace (es decir, la función
feed_the_sheepdogs() no tiene sangría y no pertenece al bloque if , lo que significa que
siempre se ejecuta).

Ahora vamos a discutir otra variante de la sentencia condicional, que también permite
realizar una acción adicional cuando no se cumple la condición.

Ejecución condicional: la sentencia if-else

Comenzamos con una frase simple que decía: Si el clima es bueno, saldremos a
caminar.
 Nota: no hay una palabra sobre lo que sucederá si el clima es malo. Solo sabemos que
no saldremos al aire libre, pero no sabemos que podríamos hacer. Es posible que
también queramos planificar algo en caso de mal tiempo.

Podemos decir, por ejemplo: Si el clima es bueno, saldremos a caminar, de lo contrario,

iremos al cine.

Ahora sabemos lo que haremos si se cumplen las condiciones, y sabemos lo que

haremos si no todo sale como queremos. En otras palabras, tenemos un "Plan B".

Python nos permite expresar dichos planes alternativos. Esto se hace con una segunda
forma, ligeramente mas compleja, de la sentencia condicional, la sentencia if-else:

1 if true_or_false_condition:
2 perform_if_condition_true
3 else:
4 perform_if_condition_false
5

Por lo tanto, hay una nueva palabra: else - esta es una palabra clave reservada.

La parte del código que comienza con else dice que hacer si no se cumple la condición
especificada por el if (observa los dos puntos después de la palabra).

La ejecución de if-else es la siguiente:

Si la condición se evalúa como True (su valor no es igual a cero), la instrucción

perform_if_condition_true se ejecuta, y la sentencia condicional llega a su fin;
Si la condición se evalúa como False (es igual a cero), la instrucción
perform_if_condition_false se ejecuta, y la sentencia condicional llega a su fin.

La sentencia if-else: más sobre ejecución condicional

Al utilizar esta forma de sentencia condicional, podemos describir nuestros planes de la

siguiente manera:

1 if the_weather_is_good:
2 go_for_a_walk()
3 else:
4 go_to_a_theater()
5 have_lunch()
6

Si el clima es bueno, saldremos a caminar. De lo contrario, iremos al cine. No importa si

el clima es bueno o malo, almorzaremos después (después de la caminata o después de
ir al cine).

Todo lo que hemos dicho sobre la sangría funciona de la misma manera dentro de la
rama else:

1 if the_weather_is_good:
2 go_for_a_walk()
3 have_fun()
4 else:
5 go_to_a_theater()
6 enjoy_the_movie()
7 have_lunch()
8

Sentencias if-else anidadas

Ahora, analicemos dos casos especiales de la sentencia condicional.

Primero, considera el caso donde la instrucción colocada después del if es otro if .

Lee lo que hemos planeado para este Domingo. Si hay buen clima, saldremos a caminar.
Si encontramos un buen restaurante, almorzaremos allí. De lo contrario, vamos a comer
un sandwich. Si hay mal clima, iremos al cine. Si no hay boletos, iremos de compras al
centro comercial más cercano.

Escribamos lo mismo en Python. Considera cuidadosamente el código siguiente:

1 if the_weather_is_good:
2 if nice_restaurant_is_found:
3 have_lunch()
4 else:
5 eat_a_sandwich()
6 else:
7 if tickets_are_available:
8 go_to_the_theater()
9 else:
10 go_shopping()

Aquí hay dos puntos importantes:

Este uso de la sentencia if se conoce como anidamiento; recuerda que cada

else se refiere al if que se encuentra en el mismo nivel de sangría; se necesita
saber esto para determinar cómo se relacionan los ifs y los else;
Considera como la sangría mejora la legibilidad y hace que el código sea más fácil
de entender y rastrear.

La sentencia elif

El segundo caso especial presenta otra nueva palabra clave de Python: elif. Como
probablemente sospechas, es una forma más corta de else if.

elif se usa para verificar más de una condición, y para detener cuando se encuentra
la primera sentencia verdadera.

Nuestro siguiente ejemplo se parece a la anidación, pero las similitudes son muy leves.
Nuevamente, cambiaremos nuestros planes y los expresaremos de la siguiente manera:
si hay buen clima, saldremos a caminar, de lo contrario, si obtenemos entradas, iremos
al cine, de lo contrario, si hay mesas libres en el restaurante, vamos a almorzar; si todo
falla, regresaremos a casa y jugaremos ajedrez.

¿Has notado cuantas veces hemos usado las palabras de lo contrario? Esta es la etapa
en la que la palabra clave reservada elif desempeña su función.

Escribamos el mismo escenario empleando Python:

1 if the_weather_is_good:
2 go_for_a_walk()
3 elif tickets_are_available:
4 go_to_the_theater()
5 elif table_is_available:
6 go_for_lunch()
7 else:
8 play_chess_at_home()
9

La forma de ensamblar las siguientes sentencias if-elif-else a veces se denomina

cascada.

Observa de nuevo como la sangría mejora la legibilidad del código.

Se debe prestar atención adicional a este caso:

No debes usar else sin un if precedente;

else siempre es la última rama de la cascada, independientemente de si has
usado elif o no;
else es una parte opcional de la cascada, y puede omitirse;
Si hay una rama else en la cascada, solo se ejecuta una de todas las ramas;
Si no hay una rama else , es posible que no se ejecute ninguna de las opciones
disponibles.

Esto puede sonar un poco desconcertante, pero ojalá que algunos ejemplos simples
ayuden a comprenderlo mejor.
 3.1.8 Análisis de muestras de código

Ahora te mostraremos algunos programas simples pero completos. No los explicaremos

a detalle, porque consideramos que los comentarios (y los nombres de las variables)
dentro del código son guías suficientes.

Todos los programas resuelven el mismo problema - encuentran el número mayor de

una serie de números y lo imprimen.

Ejemplo 1:

Comenzaremos con el caso más simple - ¿cómo identificar el mayor de los dos
números?:

1 # Se leen dos números

2 number1 = int(input("Ingresa el primer número: "))
3 number2 = int(input("Ingresa el segundo número: "))
4
5 # Elige el número más grande
6 if number1 > number2:
7 larger_number = number1
8 else:
9 larger_number = number2
10
11 # Imprime el resultado
12 print("El número más grande es:", larger_number)
13

El fragmento de código anterior debe estar claro - lee dos valores enteros, los compara
y encuentra cuál es el más grande.

Ejemplo 2:

Ahora vamos a mostrarte un hecho intrigante. Python tiene una característica interesante
- mira el código a continuación:

1 # Se leen dos números

2 number1 = int(input("Ingresa el primer número: "))
3 number2 = int(input("Ingresa el segundo número: "))
4
5 # Elige el número más grande
6 if number1 > number2: larger_number = number1
7 else: larger_number = number2
8
9 # Imprime el resultado
10 print("El número más grande es:", larger_number)
11

Nota: si alguna de las ramas de if-elif-else contiene una sola instrucción, puedes
codificarla de forma más completa (no es necesario que aparezca una línea con sangría
después de la palabra clave), pero solo continúa la línea después de los dos puntos).

Sin embargo, este estilo puede ser engañoso, y no lo vamos a usar en nuestros
programas futuros, pero definitivamente vale la pena saber si quieres leer y entender los
programas de otra persona.

No hay otras diferencias en el código.

 Ejemplo 3:

Es hora de complicar el código - encontremos el mayor de los tres números. ¿Se

ampliará el código? Un poco.

Suponemos que el primer valor es el más grande. Luego verificamos esta hipótesis con
los dos valores restantes.

Observa el siguiente código:

1 # Se leen tres números

2 number1 = int(input("Ingresa el primer número: "))
3 number2 = int(input("Ingresa el segundo número: "))
4 number3 = int(input("Ingresa el tercer número: "))
5
6 # Asumimos temporalmente que el primer número
7 # es el más grande.
8 # Lo verificaremos pronto.
9 largest_number = number1
10
11 # Comprobamos si el segundo número es más grande que el mayor número actual
12 # y actualiza el número más grande si es necesario.
13 if number2 > largest_number:
14 largest_number = number2
15
16 # Comprobamos si el tercer número es más grande que el mayor número actual
17 # y actualiza el número más grande si es necesario.
18 if number3 > largest_number:
19 largest_number = number3
20
21 # Imprime el resultado.
22 print("El número más grande es:", largest_number)
23

Este método es significativamente más simple que tratar de encontrar el número más
grande comparando todos los pares de números posibles (es decir, el primero con el
segundo, el segundo con el tercero y el tercero con el primero). Intenta reconstruir el
código por ti mismo.
  

1
2

Console  

3.1.9 Pseudocódigo e introducción a los

bucles
 Ahora deberías poder escribir un
programa que encuentre el mayor de
cuatro, cinco, seis o incluso diez
números.

Ya conoces el esquema, por lo que

ampliar el tamaño del problema no
será particularmente complejo.

¿Pero qué sucede si te pedimos que

escribas un programa que encuentre
el mayor de doscientos números? ¿Te
imaginas el código?

Necesitarás doscientas variables. Si

doscientas variables no son lo
suficientemente complicadas, intenta
imaginar la búsqueda del número más
grande de un millón.

Imagina un código que contiene 199

sentencias condicionales y doscientas
invocaciones de la función input() .
Por suerte, no necesitas lidiar con
eso. Hay un enfoque más simple.

Por ahora ignoraremos los requisitos de la sintaxis de Python e intentaremos analizar el

problema sin pensar en la programación real. En otras palabras, intentaremos escribir el
algoritmo, y cuando estemos contentos con él, lo implementaremos.

En este caso, utilizaremos un tipo de notación que no es un lenguaje de programación

real (no se puede compilar ni ejecutar), pero está formalizado, es conciso y se puede
leer. Se llama pseudocódigo.

Veamos nuestro pseudocódigo a continuación:

1 largest_number = -999999999
2 number = int(input())
3 if number == -1:
4 print(largest_number)
5 exit()
6 if number > largest_number:
7 largest_number = number
8 # Ir a la línea 02
9

¿Qué está pasando en él?

En primer lugar, podemos simplificar el programa si, al principio del código, le asignamos
a la variable largest_number un valor que será más pequeño que cualquiera de los
números ingresados. Usaremos -999999999 para ese propósito.

En segundo lugar, asumimos que nuestro algoritmo no sabrá por adelantado cuántos
números se entregarán al programa. Esperamos que el usuario ingrese todos los
números que desee - el algoritmo funcionará bien con cien y con mil números. ¿Cómo
hacemos eso?

Hacemos un trato con el usuario: cuando se ingresa el valor -1 , será una señal de que
no hay más datos y que el programa debe finalizar su trabajo.

De lo contrario, si el valor ingresado no es igual a -1 , el programa leerá otro número, y

así sucesivamente.

El truco se basa en la suposición de que cualquier parte del código se puede realizar
más de una vez - precisamente, tantas veces como sea necesario.

La ejecución de una determinada parte del código más de una vez se denomina bucle.
El significado de este término es probablemente obvio para ti.

Las líneas 02 al 08 forman un bucle. Los pasaremos tantas veces como sea
necesario para revisar todos los valores ingresados.

¿Puedes usar una estructura similar en un programa escrito en Python? Si, si puedes.

Información Adicional
 Python a menudo viene con muchas funciones integradas que harán el trabajo por ti. Por
ejemplo, para encontrar el número más grande de todos, puede usar una función
incorporada de Python llamada max() . Puedes usarlo con múltiples argumentos. Analiza
el código de abajo:

1 # Se leen tres números.

2 number1 = int(input("Ingresa el primer número: "))
3 number2 = int(input("Ingresa el segundo número: "))
4 number3 = int(input("Ingresa el tercer número: "))
5
6 # Verifica cuál de los números es el mayor
7 # y pásalo a la variable largest_number.
8
9 largest_number = max(number1, number2, number3)
10
11 # Imprime el resultado.
12 print("El número más grande es:", largest_number)
13

De la misma manera, puedes usar la función min() para devolver el número más
pequeño. Puedes reconstruir el código anterior y experimentar con él en Sandbox.

Vamos a hablar sobre estas (y muchas otras) funciones pronto. Por el momento, nuestro
enfoque se centrará en la ejecución condicional y los bucles para permitirte ganar más
confianza en la programación y enseñarte las habilidades que te permitirán comprender
y aplicar los dos conceptos en tu codigo. Entonces, por ahora, no estamos tomando
atajos.
LAB

3.1.10 LAB Operadores de

comparación y 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 , grite involuntariamente a la consola la
siguiente cadena: "¡Espatifilo es la mejor planta de todas!"

Escribe un programa que utilice el concepto de ejecución condicional, tome una cadena
como entrada y que:

imprima el enunciado "Si - ¡El Espatifilo! es la mejor planta de todos los tiempos!"
en la pantalla si la cadena ingresada es "ESPATIFILIO" (mayúsculas)
imprima "No, ¡quiero un gran Espatifilo!" si la cadena ingresada es "espatifilo"
(minúsculas)
imprima "¡Espatifilo!, ¡No [entrada]!" de lo contrario. Nota: [entrada] es la
cadena que se toma como entrada.

Prueba tu código con los datos que te proporcionamos. ¡Y hazte de un Espatifilo

también!

Datos de Prueba:
 Entrada de muestra: Salida esperada:

Output
espatifilo
No, ¡quiero un gran Espatifilo!

Entrada de muestra: Salida esperada:

Output
pelargonio
¡Espatifilo!, ¡No pelargonio!

Entrada de muestra: Salida esperada:

Output
Espatifilo
Si, ¡El Espatifilo! es la mejor planta d

  

Console  
 Solución de muestra

LAB

3.1.11 LAB Fundamentos de la

sentencia if-else

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.

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.

Nota: este país feliz nunca devuelve dinero a sus ciudadanos. Si el impuesto calculado
es menor que cero, solo significa que no hay impuesto (el impuesto es igual a cero). Ten
esto en cuenta durante tus cálculos.

Observa el código en el editor - solo lee un valor de entrada y genera un resultado, por
lo que debes completarlo con algunos cálculos inteligentes.

Prueba tu código con los datos que hemos proporcionado.

Datos de Prueba

Entrada de muestra: Salida esperada:

Output
10000
El impuesto es: 1244.0 pesos

Entrada de muestra: Salida esperada:

Output
100000
El impuesto es: 19470.0 pesos

Entrada de muestra: Salida esperada:

Output
1000
El impuesto es: 0.0 pesos

Entrada de muestra: Salida esperada:

-100
El impuesto es: 0.0 pesos
   

1 income = float(input("Introduce el ingreso anual: "))

2
3 if income < 85528:
4 tax = income * 0.18 - 556.02
5 # Escribe tu código aquí.
6
7 tax = round(tax, 0)
8 print("El impuesto es:", tax, "pesos")
9

Console  

Solución de muestra

LAB
3.1.12 LAB Fundamentos de la
sentencia if-elif-else

Escenario
Como seguramente sabrás, debido a algunas razones astronómicas, el año puede 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:

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 % .

Prueba tu código con los datos que hemos proporcionado.

Datos de Prueba:
 Entrada de muestra: Salida esperada:

Output
2000
Año bisiesto

Entrada de muestra: Salida esperada:

Output
2015
Año comun

Entrada de muestra: Salida esperada:

Output
1999
Año comun

Entrada de muestra: Salida esperada:

Output
1996
Año bisiesto

Entrada de muestra: Salida esperada:

Output
1580
No dentro del período del calendario gre

  

1 year = int(input("Introduce un año: "))

2
3 if year < 1582:
4 print("No esta dentro del período del calendario Gregoriano")
5 else:
 5 else:
6 # Escribe el bloque if-elif-elif-else aquí.
7

Console  

Solución de muestra

3.1.13 RESUMEN DE SECCIÓN

1. Los operadores de comparación (o también denominados operadores relacionales)

se utilizan para comparar valores. La siguiente tabla ilustra cómo funcionan los
operadores de comparación, asumiendo que
x = 0 , y = 1,y z = 0:

Operador Descripción Ejemplo

 == Devuelve True si los valores de los x == y # False
operandos son iguales, y False de x == z # True

lo contrario.

!= Devuelve True si los valores de los x != y # True

operandos no son iguales, y False x != z # False

de lo contrario.

> Devuelve True si el valor del x > y # False

operando izquierdo es mayor que el y > z # True

valor del operando derecho, y False

de lo contrario.

< Devuelve True si el valor del x < y # True

operando izquierdo es menor que el y < z # False

valor del operando derecho, y False

de lo contrario.

>= Devuelve True si el valor del x >= y # False

operando izquierdo es mayor o igual x >= z # True
y >= z # True
al valor del operando derecho, y
False de lo contrario.

<= Devuelve True si el valor del x <= y # True

operando izquierdo es menor o igual x <= z # True
y <= z # False
al valor del operando derecho, y
False de lo contrario.

2. Cuando deseas ejecutar algún código solo si se cumple una determinada condición,
puedes usar una sentencia condicional:

Una única sentencia if , por ejemplo:

1 x = 10
2
3 if x == 10: # condición
4 print("x es igual a 10") # Ejecutado si la condición es True.
5
 Una serie de sentencias if , por ejemplo:

1 x = 10
2
3 if x > 5: # primera condición
4 print("x es mayor que 5") # Ejecutado si la primera condición es True.
5
6 if x < 10: # segunda condición
7 print("x es menor que 10") # Ejecutado si la segunda condición es True.
8
9 if x == 10: # tercera condición
10 print("x es igual a 10") # Ejecutado si la tercera condición es True.
11

Cada sentencia if se prueba por separado.

Una sentencia if-else , por ejemplo:

1 x = 10
2
3 if x < 10: # condición
4 print("x es menor que 10") # Ejecutado si la condición es True.
5
6 else:
7 print("x es mayor o igual a 10") # Ejecutado si la condición es False.
8

Una serie de sentencias if seguidas por un bloque else , por ejemplo:

1 x = 10
2
3 if x > 5: # primera condición
4 print("x es mayor que 5") # Ejecutado si la primera condición es True.
5
6 if x < 10: # segunda condición
7 print("x es menor que 10") # Ejecutado si la segunda condición es True.
8
9 if x == 10: # tercera condición
10 print("x es igual a 10") # Ejecutado si la tercera condición es True.
11

Cada sentencia if se prueba por separado. El cuerpo del else es ejecutado si el

último if es False .

La sentencia if-elif-else , por ejemplo:

1 x = 10
2
3 if x == 10: # True
4 print("x == 10")
5
6 if x > 15: # False
7 print("x > 15")
8
9 elif x > 10: # False
10 print("x > 10")
11
12 elif x > 5: # True
13 print("x > 5")
14
15 else:
16 print("else no será ejecutado")
17

Si la condición para if es False , el programa verifica las condiciones de los bloques

elif posteriores: el primer elif que sea True es el que se ejecuta. Si todas las
condiciones son False , se ejecutará el bloque else .
 Sentencias condicionales anidadas, ejemplo:

1 x = 10
2
3 if x > 5: # True
4 if x == 6: # False
5 print("anidado: x == 6")
6 elif x == 10: # True
7 print("anidado: x == 10")
8 else:
9 print("anidado: else")
10 else:
11 print("else")
12

3.1.14 QUIZ DE SECCIÓN

Pregunta 1: ¿Cuál es el resultado del siguiente fragmento de código?

x = 5
y = 10
z = 8

print(x > y)
print(y > z)

Revisar

Pregunta 2: ¿Cuál es el resultado del siguiente fragmento de código?

x, y, z = 5, 10, 8

print(x > z)
print((y - 5) == x)

Revisar

Pregunta 3: ¿Cuál es el resultado del siguiente fragmento de código?

x, y, z = 5, 10, 8
x, y, z = z, y, x

print(x > z)
print((y - 5) == x)

Revisar

Pregunta 4: ¿Cuál es el resultado del siguiente fragmento de código?

x = 10

if x == 10:
print(x == 10)
if x > 5:
print(x > 5)
if x < 10:
print(x < 10)
else:
print("else")

Revisar
 Pregunta 5: ¿Cuál es el resultado del siguiente fragmento de código?

x = "1"

if x == 1:
print("one")
elif x == "1":
if int(x) > 1:
print("two")
elif int(x) < 1:
print("three")
else:
print("four")
if int(x) == 1:
print("five")
else:
print("six")

Revisar

Pregunta 6: ¿Cuál es el resultado del siguiente fragmento de código?

x = 1
y = 1.0
z = "1"

if x == y:
print("one")
if y == int(z):
print("two")
elif x == y:
print("three")
else:
print("four")

Revisar
3.2 Sección 2 – Bucles
en Python

Deslizar para comenzar 

En la segunda sección, aprenderás acerca de los bucles en Python y específicamente -

los bucles while y for. Aprenderás cómo crear (y evitar caer en) bucles infinitos, cómo
salir de bucles, y omitir ciertas iteraciones en los bucles. ¿Listo?
 3.2.1 Bucles en tu código con while

¿Estás de acuerdo con la sentencia presentada a continuación?

mientras haya algo que hacer

hazlo

Toma en cuenta que este registro también declara que, si no hay nada que hacer, nada
ocurrirá.

En general, en Python, un bucle se puede representar de la siguiente manera:

while
instruction

Si observas algunas similitudes con la instrucción if, está bien. De hecho, la diferencia
sintáctica es solo una: usa la palabra while en lugar de la palabra if .

La diferencia semántica es más importante: cuando se cumple la condición, if realiza sus

sentencias sólo una vez; while repite la ejecución siempre que la condición se evalúe
como True .

Nota: todas las reglas relacionadas con sangría también se aplican aquí. Te mostraremos
esto pronto.
 Observa el algoritmo a continuación:

while conditional_expression:
instruction_one
instruction_two
instruction_three
:
:
instruction_n

Ahora, es importante recordar que:

si deseas ejecutar más de una sentencia dentro de un while , debes (como con
if ) 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 (igual a cero) tan pronto como se compruebe por primera
vez, el cuerpo no se ejecuta ni una sola vez (ten en cuenta la analogía de no tener
que hacer nada si no hay nada que hacer).
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.
Observa que hacer una cosa generalmente disminuye la cantidad de cosas por
hacer.
 3.2.2 Un bucle infinito

Un bucle infinito, también denominado bucle sin fin, 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:

1 while True:
2 print("Estoy atrapado dentro de un bucle.")
3

Este bucle imprimirá infinitamente "Estoy atrapado dentro de un bucle." en la pantalla.

Nota

Si deseas obtener la mejor experiencia de aprendizaje al ver cómo se comporta un bucle

infinito, inicia IDLE, crea un nuevo archivo, copia y pega el código anterior, guarda tu
archivo y ejecuta el programa. Lo que verás es la secuencia interminable de cadenas
impresas de "Estoy atrapado dentro de un bucle." en la ventana de la consola de Python.
Para finalizar tu programa, simplemente presiona Ctrl-C (o Ctrl-Break en algunas
computadoras). Esto provocará la excepción KeyboardInterrupt y permitirá que tu
programa salga del bucle. Hablaremos de ello más adelante en el curso.

Volvamos al bosquejo del algoritmo que te mostramos recientemente. Te mostraremos

como usar este bucle recién aprendido para encontrar el número más grande de un gran
conjunto de datos ingresados.

Analiza el programa cuidadosamente. Localiza donde comienza el bucle (línea 8) y

descubre como se sale del cuerpo del bucle:

1 # Almacena el actual número más grande aquí.

2 largest_number = -999999999
3
4 # Ingresa el primer valor.
5 number = int(input("Introduce un número o escribe -1 para detener: "))
6
7 # Si el número no es igual a -1, continuaremos
8 while number != -1:
9 # ¿Es el número más grande que el valor de largest_number?
10 if number > largest_number:
11 # Sí si, se actualiza largest_number.
12 largest_number = number
13 # Ingresa el siguiente número.
14 number = int(input("Introduce un número o escribe -1 para detener: "))
15
16 # Imprime el número más grande.
17 print("El número más grande es:", largest_number)
18

Comprueba como este código implementa el algoritmo que te mostramos anteriormente.

3.2.3 El bucle while: más ejemplos

Veamos otro ejemplo utilizando el bucle while . Sigue los comentarios para descubrir la
idea y la solución.

1 # Un programa que lee una secuencia de números

2 # y cuenta cuántos números son pares y cuántos son impares.
3 # El programa termina cuando se ingresa un cero.
4
5 odd_numbers = 0
6 even_numbers = 0
7
8 # Lee el primer número.
9 number = int(input("Introduce un número o escribe 0 para detener: "))
10
11 # 0 termina la ejecución.
12 while number != 0:
13 # Verificar si el número es impar.
14 if number % 2 == 1:
15 # Incrementar el contador de números impares odd_numbers.
16 odd_numbers += 1
17 else:
18 # Incrementar el contador de números pares even_numbers.
19 even_numbers += 1
20 # Leer el siguiente número.
21 number = int(input("Introduce un número o escribe 0 para detener: "))
22
23 # Imprimir resultados.
24 print("Conteo de números impares:", odd_numbers)
25 print("Conteo de números pares:", even_numbers)
26

Ciertas expresiones se pueden simplificar sin cambiar el comportamiento del programa.

Intenta recordar cómo Python interpreta la verdad de una condición y ten en cuenta que
estas dos formas son equivalentes:

while number != 0: y while number: .

La condición que verifica si un número es impar también puede codificarse en estas

formas equivalentes:

if number % 2 == 1: y if number % 2: .

Empleando una variable counter para salir del bucle

 Observa el fragmento de código a continuación:

1 counter = 5
2 while counter != 0:
3 print("Dentro del bucle.", counter)
4 counter -= 1
5 print("Fuera del bucle.", counter)
6

Este código está destinado a imprimir la cadena "Dentro del bucle." y el valor
almacenado en la variable counter durante un bucle dado exactamente cinco veces. Una
vez que la condición se haya cumplido (la variable counter ha alcanzado 0 ), se sale del
bucle y aparece el mensaje "Fuera del bucle." así como tambien el valor almacenado en
counter se imprime.

Pero hay una cosa que se puede escribir de forma más compacta - la condición del
bucle while .

¿Puedes ver la diferencia?

1 counter = 5
2 while counter:
3 print("Dentro del bucle.", counter)
4 counter -= 1
5 print("Fuera del bucle.", counter)
6

¿Es más compacto que antes? Un poco. ¿Es más legible? Eso es discutible.

RECUERDA

No te sientas obligado a codificar tus programas de una manera que siempre sea la más
corta y la más compacta. La legibilidad puede ser un factor más importante. Manten tu
código listo para un nuevo programador.
LAB

3.2.4 LAB Adivina el número secreto

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.

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."

¡El mago está contando contigo! No lo decepciones.

INFO EXTRA
 Por cierto, observa la función print() . La forma en que lo hemos utilizado aquí se llama
impresión multilínea. Puedes utilizar comillas triples para imprimir cadenas en varias
líneas para facilitar la lectura del texto o crear un diseño especial basado en texto.
Experimenta con ello.

  

1 secret_number = 777
2
3 print(
4 """
5 +================================+
6 | ¡Bienvenido a mi juego, muggle!|
7 | Introduce un número entero |
8 | y adivina qué número he |
9 | elegido para ti. |
10 |¿Cuál es el número secreto? |
11 +================================+
12 """)
13
14
Console  

3.2.5 Bucles en tu código con for

Otro tipo de bucle disponible en Python proviene de la observación de que a veces es

más importante contar los "giros o vueltas" del bucle que verificar las condiciones.
 Imagina que el cuerpo de un bucle debe ejecutarse exactamente cien veces. Si deseas
utilizar el bucle while para hacerlo, puede tener este aspecto:

1 i = 0
2 while i < 100:
3 # do_something()
4 i += 1
5

Sería bueno si alguien pudiera hacer esta cuenta aburrida por ti. ¿Es eso posible?

Por supuesto que lo es - hay un bucle especial para este tipo de tareas, y se llama for .

En realidad, el bucle for está diseñado para realizar tareas más complicadas, puede
"explorar" grandes colecciones de datos elemento por elemento. Te mostraremos
como hacerlo pronto, pero ahora presentaremos una variante más sencilla de su
aplicación.

Observa el fragmento de código:

1 for i in range(100):
2 # do_something()
3 pass
4

Existen algunos elementos nuevos. Déjanos contarte sobre ellos:

la palabra reservada for abre el bucle for ; nota - 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() (esta es una función muy especial) es responsable de generar
todos los valores deseados de la variable de control; en nuestro ejemplo, la función
 creará (incluso podemos decir que alimentará el bucle con) valores subsiguientes
del siguiente conjunto: 0, 1, 2 .. 97, 98, 99; nota: en este caso, la función range()
comienza su trabajo desde 0 y lo finaliza un paso (un número entero) antes del
valor de su argumento.
nota la palabra clave pass dentro del cuerpo del bucle - no hace nada en absoluto;
es una instrucción vacía - la colocamos aquí porque la sintaxis del bucle for
exige al menos una instrucción dentro del cuerpo (por cierto - if , elif , else y
while expresan lo mismo).

Nuestros próximos ejemplos serán un poco más modestos en el número de repeticiones

de bucle.

Echa un vistazo al fragmento de código. ¿Puedes predecir su output?

  

1 for i in range(10):
2 print("El valor de i es", i)
3

Console  

Ejecuta el código para verificar si tenías razón.

Nota:

El bucle se ha ejecutado diez veces (es el argumento de la función range() )

 El valor de la última variable de control es 9 (no 10 , ya que comienza desde 0 ,
no desde 1 )

La invocación de la función range() puede estar equipada con dos argumentos, no solo
uno:

1 for i in range(2, 8):

2 print("El valor de i es", i)
3

En este caso, el primer argumento determina el valor inicial (primero) de la variable de

control.

El último argumento muestra el primer valor que no se asignará a la variable de control.

Nota: la función range() solo acepta enteros como argumentos y genera secuencias
de enteros.

¿Puedes adivinar la output del programa? Ejecútalo para comprobar si ahora también
estabas en lo cierto.

El primer valor mostrado es 2 (tomado del primer argumento de range() ).

El último es 7 (aunque el segundo argumento de range() es 8 ).

 3.2.6 Más acerca del bucle for y la
función range() con tres argumentos
La función range() también puede aceptar tres argumentos: Echa un vistazo al código del editor.

  

1 for i in range(2, 8, 3):

2 print("El valor de i es", i)
3
4

Console  

El tercer argumento es un incremento - es un valor agregado para controlar la variable en cada

giro del bucle (como puedes sospechar, el valor predeterminado del incremento es 1).

¿Puedes decirnos cuántas líneas aparecerán en la consola y qué valores contendrán?

Ejecuta el programa para averiguar si tenías razón.

Deberías poder ver las siguientes líneas en la ventana de la consola:

Output
El valor de i es 2
El valor de i es 5
 ¿Sabes por qué? El primer argumento pasado a la función range() nos dice cual es el
número de inicio de la secuencia (por lo tanto 2 en la output). El segundo argumento le
dice a la función dónde detener la secuencia (la función genera números hasta el
número indicado por el segundo argumento, pero no lo incluye). Finalmente, el tercer
argumento indica el paso, que en realidad significa la diferencia entre cada número en la
secuencia de números generados por la función.

2 (número inicial) → 5 ( 2 incremento por 3 es igual a 5 - el número está dentro del

rango de 2 a 8) → 8 ( 5 incremento por 3 es igual a 8 - el número no está dentro del
rango de 2 a 8, porque el parámetro de parada no está incluido en la secuencia de
números generados por la función).

Nota: si el conjunto generado por la función range() está vacío, el bucle no ejecutará su
cuerpo en absoluto.

Al igual que aquí - no habrá output:

1 for i in range(1, 1):

2 print("El valor de i es", i)
3

Nota: el conjunto generado por range() debe ordenarse en un orden ascendente. No

hay forma de forzar el range() para crear un conjunto en una forma diferente. Esto
significa que el segundo argumento de range() debe ser mayor que el primero.

Por lo tanto, tampoco habrá output aquí:

1 for i in range(2, 1):

2 print("El valor de i es", i)
3

Echemos un vistazo a un programa corto cuya tarea es escribir algunas de las primeras potencias
de dos:
   

1 power = 1
2 for expo in range(16):
3 print("2 a la potencia de", expo, "es", power)
4 power *= 2
5

Console  

La variable expo se utiliza como una variable de control para el bucle e indica el valor actual del
exponente. La propia exponenciación se sustituye multiplicando por dos. Dado que 2 0 es igual a
1, después 2 × 1 es igual a 21, 2 × 21 es igual a 22, y así sucesivamente. ¿Cuál es el máximo
exponente para el cual nuestro programa aún imprime el resultado?

Ejecuta el código y verifica si la output coincide con tus expectativas.

LAB
3.2.7 LAB Fundamentos del bucle for –
contando lentamente (mississippily)

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.

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.

INFO EXTRA

Ten en cuenta que el código en el editor contiene dos elementos que pueden no ser del
todo claros en este momento: la sentencia import time y el método sleep() . Vamos a
hablar de ellos pronto.

Por el momento, nos gustaría que supieras que hemos importado el módulo time y
hemos utilizado el método sleep() para suspender la ejecución de cada función
posterior de print() dentro del bucle for durante un segundo, de modo que el mensaje
 enviado a la consola se parezca a un conteo real. No te preocupes - pronto aprenderás
más sobre módulos y métodos.

Salida esperada:

Output

1 Mississippi
2 Mississippi
3 Mississippi
4 Mississippi
5 Mississippi

  

1 import time
2
3 # Escribe un bucle for que cuente hasta cinco.
4 # Cuerpo del bucle: imprime el número de iteración del bucle y la palabra "
5 # Cuerpo del bucle, emplea : time.sleep(1)
6
7 # Escribe una función print con el mensaje final.
8
9

Console  
 3.2.8 Las sentencias break y continue

Hasta ahora, hemos tratado el cuerpo del bucle como una secuencia indivisible e
inseparable de instrucciones que se realizan completamente en cada giro del bucle. Sin
embargo, como desarrollador, podrías enfrentar las siguientes opciones:

parece que no es necesario continuar el bucle en su totalidad; se debe abstener de

seguir ejecutando el cuerpo del bucle e ir más allá;
parece que necesitas comenzar el siguiente giro del bucle sin completar la
ejecución del turno actual.

Python proporciona dos instrucciones especiales para la implementación de estas dos

tareas. Digamos por razones de precisión que su existencia en el lenguaje no es
necesaria - un programador experimentado puede codificar cualquier algoritmo sin estas
instrucciones. Tales adiciones, que no mejoran el poder expresivo del lenguaje, sino que
solo simplifican el trabajo del desarrollador, a veces se denominan dulces sintácticos o
azúcar sintáctica.

Estas dos instrucciones son:

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.

Ambas palabras son palabras clave reservadas.

Ahora te mostraremos dos ejemplos simples para ilustrar como funcionan las dos
instrucciones. Mira el código en el editor. Ejecuta el programa y analiza la output.
Modifica el código y experimenta.

  
 1 # break - ejemplo
2
3 print("La instrucción break:")
4 for i in range(1, 6):
5 if i == 3:
6 break
7 print("Dentro del bucle.", i)
8 print("Fuera del bucle.")
9
10
11 # continue - ejemplo
12
13 print("\nLa instrucción continue:")
14 for i in range(1, 6):
Console  

Las sentencias break y continue: más ejemplos

Regresemos a nuestro programa que reconoce el más grande entre los números ingresados. Lo
convertiremos dos veces, usando las instrucciones de break y continue .

Analiza el código y determina como las usarías.

La variante empleando break es la siguiente:

  

1 largest_number = -99999999
2 counter = 0
3
4 while True:
5 number = int(input("Ingresa un número o escribe -1 para finalizar el pro
6 if number == -1:
7 break
8 counter += 1
9 if number > largest_number:
10 largest_number = number
11
12 if counter != 0:
13 print("El número más grande es", largest_number)
14 else:
Console  
Ejecútalo, pruébalo y experimenta con él.

Y ahora la variante con continue :

  

1 largest_number = -99999999
2 counter = 0
3
4 number = int(input("Ingresa un número o escribe -1 para finalizar el program
5
6 while number != -1:
7 if number == -1:
8 continue
9 counter += 1
10
11 if number > largest_number:
12 largest_number = number
13 number = int(input("Ingresa un número o escribe -1 para finalizar el pro
14
Console  

Observa con atención, el usuario ingresa el primer número antes de que el programa ingrese al
bucle while . El número siguiente se ingresa cuando el programa ya está en el bucle.

De nuevo - ejecútalo, pruébalo y experimenta con él.

LAB

3.2.9 LAB La sentencia break -

atrapado en un bucle

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 output
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 .

  

Console  
LAB

3.2.10 LAB La sentencia continue – el

Feo Devorador de Vocales

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 bucles 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 .

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
método upper() muy pronto, no te preocupes
utiliza la ejecución condicional y la instrucción continue para "devorar" 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

Prueba tu programa con los datos que le proporcionamos.

Datos de Prueba:

Entrada de muestra: Salida esperada:

Output
Gregory
G
R
G
R
Y

Entrada de muestra: Salida esperada:

Output
abstemious
B
S
T
M
S

Entrada de muestra: Salida esperada:

IOUEA
 Output

  

1 # Indicar al usuario que ingrese una palabra

2 # y asignarlo a la variable user_word.
3
4 for letter in user_word:
5 # Completa el cuerpo del bucle for.
6
7

Console  

LAB
3.2.11 LAB La sentencia continue – el
Lindo Devorador de Vocales

Escenario
Tu tarea aquí es aún más especial que antes: ¡Debes rediseñar el devorador de vocales
(feo) del laboratorio anterior y crear un mejor devorador de vocales (lindo) mejorado!
Escribe un programa que use:

un bucle for .
el concepto de ejecución condicional (if-elif-else).
la instrucción continue .

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 "devorar" las
siguientes vocales A , E , I , O , U de la palabra ingresada.
asigna las letras no consumidas a la variable word_without_vowels e imprime la
variable en la pantalla.

Analiza el código en el editor. Hemos creado word_without_vowels y le hemos asignado

una cadena vacía. Utiliza la operación de concatenación para pedirle a Python que
combine las letras seleccionadas en una cadena más larga durante los siguientes giros
de bucle, y asignarlo a la variable word_without_vowels .

Prueba tu programa con los datos que le proporcionamos.

Datos de Prueba:
 Entrada de muestra: Salida esperada:

Output
Gregory
GRGRY

Entrada de muestra: Salida esperada:

Output
abstemious
BSTMS

Entrada de muestra: Salida esperada:

Output
IOUEA

  

1 word_without_vowels = ""
2
3 # Indicar al usuario que ingrese una palabra
4 # y asignarla a la variable user_word.
5
6
7 for letter in user_word:
8 # Completa el cuerpo del bucle.
9
10 # Imprimir la palabra asignada a word_without_vowels.
11
12

Console  
 3.2.12 El bucle while y el bloque else
Ambos bucles while y for , tienen una característica interesante (y rara vez se usa).

Te mostraremos como funciona - intenta juzgar por ti mismo si es utilizable.

En otras palabras, trata de convencerte si la función es valiosa y útil, o solo es azúcar sintáctica.

Echa un vistazo al fragmento en el editor. Hay algo extraño al final - la palabra reservada else .

Como pudiste haber sospechado, los bucles también pueden tener la rama else , como los if .

La rama else del bucle siempre se ejecuta una vez, independientemente de si el bucle ha
entrado o no en su cuerpo.

¿Puedes adivinar la output? Ejecuta el programa para comprobar si tenías razón.

  

1 i = 1
 2 while i < 5:
3 print(i)
4 i += 1
5 else:
6 print("else:", i)
7
8

Console  

Modifica el fragmento un poco para que el bucle no tenga oportunidad de ejecutar su cuerpo ni
una sola vez:

  

1 i = 5
2 while i < 5:
3 print(i)
4 i += 1
5 else:
6 print("else:", i)
7
8

Console  

El estado del while es False al principio - ¿puedes verlo?

Ejecuta y prueba el programa, y verifica si se ha ejecutado o no la rama else .

3.2.13 El bucle for y el bloque else

Los bucles for se comportan de manera un poco diferente - echa un vistazo al fragmento en el
editor y ejecútalo.

  

1 for i in range(5):
2 print(i)
3 else:
4 print("else:", i)
5
6

Console  

La output puede ser un poco sorprendente.

La variable i conserva su último valor.

Modifica el código un poco para realizar un experimento más.

  

1 i = 111
2 for i in range(2, 1):
3 print(i)
4 else:
5 print("else:", i)
6
7

Console  

¿Puedes adivinar la output?

El cuerpo del bucle no se ejecutará aquí en absoluto. Nota: hemos asignado la variable
i antes del bucle.

Ejecuta el programa y verifica su output.

Cuando el cuerpo del bucle no se ejecuta, la variable de control conserva el valor que
tenía antes del bucle.

Nota: si la variable de control no existe antes de que comience el bucle, no existirá

cuando la ejecución llegue a la rama else branch.

¿Cómo te sientes acerca de esta variante de else ?

Ahora vamos a informarte sobre otros tipos de variables. Nuestras variables actuales
solo pueden almacenar un valor a la vez, pero hay variables que pueden hacer mucho
más - pueden almacenar tantos valores como desees. Pero primero hagamos algunos
laboratorios.
LAB

3.2.14 LAB Fundamentos del bucle

while

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:

 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.

Prueba tu código con los datos que hemos proporcionado.

Datos de Prueba

Entrada de muestra: Salida esperada:

Output
6
La altura de la pirámide es: 3

Entrada de muestra: Salida esperada:

20
 Output

La altura de la pirámide: 3

Entrada de muestra: Salida esperada:

Output
1000
La altura de la pirámide: 44

Entrada de muestra: Salida esperada:

Output
2
La altura de la pirámide: 1

  

1 blocks = int(input("Ingresa el número de bloques: "))

2
3 #
4 # Escribe tu código aquí.
5 #
6
7 print("La altura de la pirámide:", height)
8
9

Console  
LAB

3.2.15 LAB La hipótesis de Collatz

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 ≠ 1 , salta al punto 2.

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.

Prueba tu código con los datos que hemos proporcionado.

Datos de Prueba:

Entrada de muestra: Salida esperada:

Output
15
46
46
70
35
106
53
160
80
40
20
10
5
16
8
4
2
1
pasos = 17

Entrada de muestra: Salida esperada:

16
8
4
2
 1
pasos = 4

Entradaa de muestra: Salida esperada:

1023
3070
1535
4606
2303
6910
3455
10366
5183
15550
7775
23326
11663
34990
17495
52486
26243
78730
39365
118096
59048
29524
14762
7381
22144
11072
5536
2768
1384
692
346
173
173
 260
130
65
196
98
49
148
74
37
37
56
28
14
7
22
11
34
17
52
26
13
40
20
10
5
16
8
4
2
pasos = 62

  

1
Console  

3.2.16 RESUMEN DE SECCIÓN

1. Existen dos tipos de bucles en Python: while y for :

El bucle while ejecuta una sentencia o un conjunto de sentencias siempre que una
condición booleana especificada sea verdadera, por ejemplo:

1 # Ejemplo 1
2 while True:
3 print("Atrapado en un bucle infinito.")
4
5 # Ejemplo 2
6 counter = 5
7 while counter > 2:
8 print(counter)
9 counter -= 1
10

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; pronto aprenderás sobre ellos) u otros objetos que son iterables (por
ejemplo, cadenas). 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:

1 # Ejemplo 1
2 word = "Python"
3 for letter in word:
4 print(letter, end="*")
5
6 # Ejemplo 2
7 for i in range(1, 10):
8 if i % 2 == 0:
9 printprint(i)
10

2. Puedes usar las sentencias break y continue para cambiar el flujo de un bucle:

Utiliza break para salir de un bucle, por ejemplo:

1 text = "OpenEDG Python Institute

2 for letter in text:
3 if letter == "P":
4 break
5 print(letter, end="")
6

Utiliza continue para omitir la iteración actual, y continuar con la siguiente iteración,
por ejemplo:
1 text = "pyxpyxpyx
2 for letter in text:
3 if letter == "x":
4 continue
5 print(letter, end="")
6

3. Los bucles while y for también pueden tener una cláusula else en Python. La
cláusula else se ejecuta después de que el bucle finalice su ejecución siempre y
cuando no haya terminado con break , por ejemplo:

1 n = 0
2
3 while n != 3:
4 print(n)
5 n += 1
6 else:
7 print(n, "else")
8
9 print()
10
11 for i in range(0, 3):
12 print(i)
13 else:
14 print(i, "else")
15

4. 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).
y step es un parámetro opcional que especifica la diferencia entre los números en
la secuencia es (1 por defecto.)
 Código de ejemplo:

1 for i in range(3):
2 print(i, end=" ") # output: 0 1 2
3
4 for i in range(6, 1, -2):
5 print(i, end=" ") # output: 6, 4, 2
6

3.2.17 QUIZ DE SECCIÓN

Pregunta 1: Crea un bucle for que cuente de 0 a 10, e imprima números impares en la
pantalla. Usa el esqueleto de abajo:

for i in range(1, 11):

# Línea de código.
# Línea de código.

Revisar
 Pregunta 2: Crea un bucle while que cuente de 0 a 10, e imprima números impares en
la pantalla. Usa el esqueleto de abajo:

x = 1
while x < 11:
# Línea de código.
# Línea de código.
# Línea de código.

Revisar
 Pregunta 3: Crea un programa con un bucle for y una sentencia break . El programa
debe iterar sobre los caracteres en una dirección de correo electrónico, salir del bucle
cuando llegue al símbolo @ e imprimir la parte antes de @ en una línea. Usa el
esqueleto de abajo:

for ch in "[email protected]":
if ch == "@":
# Línea de código.
# Línea de código.

Revisar

Pregunta 4: Crea un programa con un bucle for y una sentencia continue . El programa
debe iterar sobre una cadena de dígitos, reemplazar cada 0 con x , e imprimir la
cadena modificada en la pantalla. Usa el esqueleto de abajo:

for digit in "0165031806510":

if digit == "0":
# Línea de código.
# Línea de código.
# Línea de código.
Revisar

Pregunta 5: ¿Cuál es la output del siguiente código?

n = 3

while n > 0:
print(n + 1)
n -= 1
else:
print(n)

Revisar

Pregunta 6: ¿Cuál es la output del siguiente código?

n = range(4)

for num in n:
print(num - 1)
else:
 print(num)

Revisar

Pregunta 7: ¿Cuál es la output del siguiente código?

for i in range(0, 6, 3):

print(i)

Revisar
3.3 Sección 3 –
Operaciones lógicas y
de bits en Python

Deslizar para comenzar 

En esta sección, aprenderás sobre los operadores lógicos y de bit a bit en Python,
conceptos como las tablas de verdad y el desplazamiento de bits.
 3.3.1 Lógica de computadoras

¿Te has dado cuenta de que las condiciones que hemos usado hasta ahora han sido muy
simples, por no decir, bastante primitivas? Las condiciones que utilizamos en la vida real
son mucho más complejas. Veamos este enunciado:

Si tenemos tiempo libre, y el clima es bueno, saldremos a caminar.

Hemos utilizado la conjunción and (y) , lo que significa que salir a caminar depende del
cumplimiento simultáneo de estas dos condiciones. En el lenguaje de la lógica, tal
conexión de condiciones se denomina conjunción. Y ahora otro ejemplo:

Si tu estás en el centro comercial o yo estoy en el centro comercial, uno de nosotros le

comprará un regalo a mamá.

La aparición de la palabra or (o) significa que la compra depende de al menos una de

estas condiciones. En lógica, este compuesto se llama una disyunción.

Está claro que Python debe tener operadores para construir conjunciones y
disyunciones. Sin ellos, el poder expresivo del lenguaje se debilitaría sustancialmente.
Se llaman operadores lógicos.

El operador 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. Nos
permite codificar condiciones complejas sin el uso de paréntesis como este:

counter > 0 and value == 100

El resultado proporcionado por el operador and se puede determinar sobre la base de la
tabla de verdad.

Si consideramos la conjunción de A and B , el conjunto de valores posibles de

argumentos y los valores correspondientes de conjunción se ve de la siguiente manera:

Argumento A Argumento B A and B

False False False

False True False

True False False

True True True

El operador or
Un operador de disyunción es la palabra or . Es un operador binario con una prioridad
más baja que and (al igual que + en comparación con * ). Su tabla de verdad es la
siguiente:

Argumento A Argumento B A or B

False False False

False True True

True False True

True True True

 El operador not
Además, hay otro operador que se puede aplicar para condiciones de construcción. 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 not Argumento

False True

True False

3.3.2 Expresiones lógicas

Creemos una variable llamada var y asignémosle 1 . Las siguientes condiciones son
equivalentes a pares:

1 # Ejemplo 1:
2 print(var > 0)
3 print(not (var <= 0))
4
5
6 # Ejemplo 2:
7 print(var != 0)
8 print(not (var == 0))
9

Puedes estar familiarizado con las leyes de De Morgan. Dicen que:

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.

Escribamos lo mismo usando Python:

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

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

Observa como se han utilizado los paréntesis para codificar las expresiones - las
colocamos allí para mejorar la legibilidad.

Deberíamos agregar que ninguno de estos operadores de dos argumentos se puede

usar en la forma abreviada conocida como op= . Vale la pena recordar esta excepción.
 3.3.3 Valores lógicos vs 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 .

1 i = 1
2 j = not not i
3

3.3.4 Operadores bit a bit

Sin embargo, hay cuatro operadores que le permiten manipular bits de datos
individuales. Se denominan operadores bit a bit.

Cubren todas las operaciones que mencionamos anteriormente en el contexto lógico, y

un operador adicional. Este es el operador xor (significa o exclusivo ), y se denota
como ^ (signo de intercalación).

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).

Operaciones bit a bit ( & , | , y ^ )

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

0 0 0 0 0

0 1 0 1 1

1 0 0 1 1

1 1 1 1 0

Operaciones bit a bit ( ~ )

Argumento ~ Argumento

0 1

1 0

Hagámoslo más fácil:

& requieres exactamente dos 1 s para proporcionar 1 como resultado;

| requiere al menos un 1 para proporcionar 1 como resultado;
^ requiere exactamente un 1 para proporcionar 1 como resultado.

Agreguemos un comentario importante: los argumentos de estos operadores deben ser

enteros; no debemos usar flotantes aquí.

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).

Operaciones lógicas vs operaciones de bit

Ahora te mostraremos un ejemplo de la diferencia en la operación entre las operaciones
lógicas y de bit. Supongamos que se han realizado las siguientes tareas:

1 i = 15
2 j = 22
3

Si asumimos que los enteros se almacenan con 32 bits, la imagen a nivel de bits de las
dos variables será la siguiente:

i: 00000000000000000000000000001111
j: 00000000000000000000000000010110

Se ejecuta la asignación:

1 log = i and j
2

Estamos tratando con una conjunción lógica aquí. Vamos a trazar el curso de los
cálculos. Ambas variables i y j no son ceros, por lo que se considerará que
representan a True . Al consultar la tabla de verdad para el operador and , podemos ver
que el resultado será True . No se realizan otras operaciones.

log: True
 Ahora la operación a nivel de bits - aquí está:

1 bit = i & j
2

El operador & operará con cada par de bits correspondientes por separado,
produciendo los valores de los bits relevantes del resultado. Por lo tanto, el resultado
será el siguiente:

i 00000000000000000000000000001111

j 00000000000000000000000000010110

bit = i & j 00000000000000000000000000000110

Estos bits corresponden al valor entero de seis.

Veamos ahora los operadores de negación. Primero el lógico:

1 logneg = not i
2

La variable logneg se establecerá en False - no es necesario hacer nada más.

La negación a nivel de bits es así:

1 bitneg = ~i
2

Puede ser un poco sorprendente: el valor de la variable bitneg es -16 . Esto puede
parecer extraño, pero no lo es en absoluto. Si deseas obtener más información, debes
consultar el sistema de números binarios y las reglas que rigen los números de
complemento de dos.
 i 00000000000000000000000000001111

bitneg = ~i 11111111111111111111111111110000

Cada uno de estos operadores de dos argumentos se puede utilizar en forma

abreviada. Estos son los ejemplos de sus notaciones equivalentes:

x = x & y x &= y

x = x | y x |= y

x = x ^ y x ^= y

3.3.5 ¿Cómo tratar con bits individuales?

Ahora te mostraremos para que puedes usar los operadores de bit a bit. Imagina que
eres un desarrollador obligado a escribir una pieza importante de un sistema operativo.
Se te ha dicho que puedes usar una variable asignada de la siguiente forma:

flag_register = 0x1234

La variable almacena la información sobre varios aspectos de la operación del sistema.

Cada bit de la variable almacena un valor de si/no. También se te ha dicho que solo
uno de estos bits es tuyo - el tercero (recuerda que los bits se numeran desde cero y el
 número de bits cero es el más bajo, mientras que el más alto es el número 31). Los bits
restantes no pueden cambiar, porque están destinados a almacenar otros datos. Aquí
está tu bit marcado con la letra x :

flag_register = 0000000000000000000000000000x000

Es posible que tengas que hacer frente a las siguientes tareas:

1. Comprobar el estado de tu bit - deseas averiguar el valor de su bit; comparar la

variable completa con cero no hará nada, porque los bits restantes pueden tener valores
completamente impredecibles, pero puedes usar la siguiente propiedad de conjunción:

1 x & 1 = x
2 x & 0 = 0
3

Si aplicas la operación & a la variable flag_register junto con la siguiente imagen de

bits:

00000000000000000000000000001000

(observa el 1 en la posición de tu bit) como resultado, obtendrás una de las siguientes

cadenas de bits:

00000000000000000000000000001000 si tu bit se estableció en 1

00000000000000000000000000000000 si tu bit se reseteo a 0

Dicha secuencia de ceros y unos, cuya tarea es tomar el valor o cambiar los bits
seleccionados, se denomina máscara de bits.

Construyamos una máscara de bits para detectar el estado de tus bits. Debería apuntar a
el tercer bit. Ese bit tiene el peso de 23=8 . Se podría crear una máscara adecuada
mediante la siguiente sentencia:
1 the_mask = 8
2

También puedes hacer una secuencia de instrucciones dependiendo del estado de tu

bit, aquí está:

1 if flag_register & the_mask:

2 # Mi bit se estableció en 1.
3 else:
4 # Mi bit se restableció a 0.
5

2. Reinicia tu bit - asigna un cero al bit, mientras que todos los otros bits deben
permanecer sin cambios; usemos la misma propiedad de la conjunción que antes, pero
usemos una máscara ligeramente diferente - exactamente como se muestra a
continuación:

11111111111111111111111111110111

Toma en cuenta que la máscara se creó como resultado de la negación de todos los bits
de la variable the_mask . Restablecer el bit es simple, y se ve así (elige el que más te
guste):

1 flag_register = flag_register & ~the_mask

2 flag_register &= ~the_mask
3

3. Establece tu bit - asigna un 1 a tu bit, mientras que todos los bits restantes deben
permanecer sin cambios; usa la siguiente propiedad de disyunción:
1 x | 1 = 1
2 x | 0 = x
3

Ya estás listo para configurar su bit con una de las siguientes instrucciones:

1 flag_register = flag_register | the_mask

2 flag_register |= the_mask
3

4. Niega tu bit - reemplaza un 1 con un 0 y un 0 con un 1 . Puedes utilizar una

propiedad interesante del operador ~x :

1 x ^ 1 = ~x
2 x ^ 0 = x
3

Niega tu bit con las siguientes instrucciones:

1 flag_register = flag_register ^ the_mask

2 flag_register ^= the_mask
3
3.3.6 Desplazamiento binario a la
izquierda y desplazamiento binario a la
derecha

Python ofrece otra operación relacionada con los bits individuales: shifting. Esto se
aplica solo a los valores de número entero, y no debe usar flotantes como argumentos
para ello.

Ya aplicas esta operación muy a menudo y muy inconscientemente. ¿Cómo multiplicas

cualquier número por diez? Echa un vistazo:

12345 × 10 = 123450

Como puede ver, multiplicar por diez es de hecho un desplazamiento de todos los
dígitos a la izquierda y llenar el vacío resultante con cero.

¿División entre diez? Echa un vistazo:

12340 ÷ 10 = 1234

Dividir entre diez no es más que desplazar los dígitos a la derecha.

 La computadora realiza el mismo tipo de operación, pero con una diferencia: como dos
es la base para los números binarios (no 10), desplazar un valor un bit a la izquierda
corresponde a multiplicarlo por dos; respectivamente, desplazar un bit a la derecha
es como dividir entre dos (observa que se pierde el bit más a la derecha).

Los operadores de cambio en Python son un par de dígrafos: < < y > > , sugiriendo
claramente en qué dirección actuará el cambio.

valor << bits

valor >> bits

El argumento izquierdo de estos operadores es un valor entero cuyos bits se

desplazan. El argumento correcto determina el tamaño del desplazamiento.

Esto demuestra que esta operación ciertamente no es conmutativa

La prioridad de estos operadores es muy alta. Los verás en la tabla de prioridades

actualizada, que te mostraremos al final de esta sección.

Echa un vistazo a los turnos en la ventana del editor.

  

1 var = 17
2 var_right = var >> 1
3 var_left = var << 2
4 print(var, var_left, var_right)
5

Console  
 La invocación final de print() produce el siguiente resultado:

Output
17 68 8

Nota:

17 >> 1 → 17 // 2 (17 dividido entre 2 a la potencia de 1) → 8 (desplazarse hacia

la derecha en un bit equivale a la división entera entre dos)
17 << 2 → 17 * 4 (17 multiplicado por 2 a la potencia de 2) → 68 (desplazarse
hacia la izquierda dos bits es lo mismo que multiplicar números enteros por cuatro)

Y aquí está la tabla de prioridades actualizada , que contiene todos los operadores
presentados hasta ahora:

Prioridad Operador

1 ~ , +, - unario

2 **

3 * , / , // , %

4 + , - binario

5 << , >>

6 < , <= , > , >=

7 == , !=

8 &

9 |

10 = , += , -= , *= , /= , %= , &= , ^= , |= , >>= , <<=

3.3.7 RESUMEN DE SECCIÓN

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. Puedes utilizar operadores bit a bit para manipular bits de datos individuales. Los
siguientes datos de muestra:

x = 15 , el cual es 0000 1111 en binario,

y = 16 , el cual es 0001 0000 en binario.

Se utilizarán para ilustrar el significado de operadores bit a bit en Python. Analiza los
ejemplos a continuación:

& 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 = , el cual
es 1000 0000 en binario.

* -16 (decimal del complemento a 2 con signo) -- lee más acerca de la operación
Complemento a dos.

3.3.8 QUIZ DE SECCIÓN

Pregunta 1: ¿Cuál es el resultado del siguiente fragmento de código?

1 x = 1
2 y = 0
3
4 z = ((x == y) and (x == y)) or not(x == y)
5 print(not(z))
6

Revisar
 Pregunta 2: ¿Cuál es el resultado del siguiente fragmento de código?

1 x = 4
2 y = 1
3
4 a = x & y
5 b = x | y
6 c = ~x # ¡difícil!
7 d = x ^ 5
8 e = x >> 2
9 f = x << 2
10
11 print(a, b, c, d, e, f)
12

Revisar
 3.4 Sección 4 – Listas

Deslizar para comenzar 

¡Bienvenido la sección 4! Aquí aprenderás sobre las listas de Python y cómo realizar
varias operaciones en ellas. Aprenderás a cómo indexar, actualizar y eliminar elementos
de lista, cómo crear rodajas y cómo usar algunas de las funciones y métodos de lista
más importantes.
 3.4.1 ¿Por qué necesitamos listas?

Puede suceder que tengas que leer, almacenar, procesar y, finalmente, imprimir
docenas, quizás cientos, tal vez incluso miles de números. ¿Entonces qué? ¿Necesitas
crear una variable separada para cada valor? ¿Tendrás que pasar largas horas
escribiendo sentencias como la que se muestra a continuación?

var1 = int(input())
var2 = int(input())
var3 = int(input())
var4 = int(input())
var5 = int(input())
var6 = int(input())
:
:

Si no crees que esta sea una tarea complicada, toma un papel y escribe un programa
que:

lea cinco números.

los imprima en orden desde el más pequeño hasta el más grande (Este tipo de
procesamiento se denomina ordenamiento).

Debes percatarte que ni siquiera tienes suficiente papel para completar la tarea.

Hasta ahora, has aprendido como declarar variables que pueden almacenar exactamente
un valor dado a la vez. Tales variables a veces se denominan escalares por analogía con
las matemáticas. Todas las variables que has usado hasta ahora son realmente
escalares.

Piensa en lo conveniente que sería declarar una variable que podría almacenar más de
un valor. Por ejemplo, cien, o mil o incluso diez mil. Todavía sería una y la misma
 variable, pero muy amplia y espaciosa. ¿Suena atractivo? Quizás, pero ¿cómo
manejarías un contenedor así lleno de valores diferentes? ¿Cómo elegirías solo el que
necesitas?

¿Y si solo pudieras numerarlos? Y luego di: dame el valor número 2; asigna el valor
número 15; aumenta el número del valor 10000.

Te mostraremos como declarar tales variables de múltiples valores. Haremos esto con
el ejemplo que acabamos de sugerir. Escribiremos un programa que ordene una
secuencia de números. No seremos particularmente ambiciosos - asumiremos que hay
exactamente cinco números.

Vamos a crear una variable llamada numbers ; se le asigna no solo un número, sino que se
llena con una lista que consta de cinco valores (nota: la lista comienza con un corchete
abierto y termina con un corchete cerrado; el espacio entre los corchetes es llenado
con cinco números separados por comas).

numbers = [10, 5, 7, 2, 1]

Digamos lo mismo utilizando una terminología adecuada: numbers es una lista que
consta de cinco valores, todos ellos números. También podemos decir que esta
sentencia crea una lista de longitud igual a cinco (ya que contiene cinco elementos).

Los elementos dentro de una lista pueden tener diferentes tipos. Algunos de ellos
pueden ser enteros, otros son flotantes y otros pueden ser listas.

Python ha adoptado una convención que indica que los elementos de una lista están
siempre numerados desde cero. Esto significa que el elemento almacenado al principio
de la lista tendrá el número cero. Como hay cinco elementos en nuestra lista, al último
de ellos se le asigna el número cuatro. No olvides esto.

Pronto te acostumbrarás, y se convertirá en algo natural.

Antes de continuar con nuestra discusión, debemos indicar lo siguiente: nuestra lista es
una colección de elementos, pero cada elemento es un escalar.
 3.4.2 Indexación de listas

¿Cómo cambias el valor de un elemento elegido en la lista?

Vamos a asignar un nuevo valor de 111 al primer elemento en la lista. Lo hacemos de

esta manera:

1 numbers = [10, 5, 7, 2, 1]
2 print("Contenido de la lista:", numbers) # Imprimiendo contenido de la lista
3
4 numbers[0] = 111
5 print("Nuevo contenido de la lista: ", numbers) # Contenido actual de la list
6

Y ahora queremos copiar el valor del quinto elemento al segundo elemento - ¿puedes
adivinar cómo hacerlo?

1 numbers = [10, 5, 7, 2, 1]
2 print("Contenido de la lista original:", numbers) # Imprimiendo contenido de
3
4 numbers[0] = 111
5 print("\nPrevio contenido de la lista:", numbers) # Imprimiendo contenido de
6
7 numbers[1] = numbers[4] # Copiando el valor del quinto elemento al segundo e
8 print("Nuevo contenido de la lista:", numbers) # Imprimiendo el contenido de
9

El valor dentro de los corchetes que selecciona un elemento de la lista se llama un

índice, mientras que la operación de seleccionar un elemento de la lista se conoce como
indexación.

Vamos a utilizar la función print() para imprimir el contenido de la lista cada vez que
realicemos los cambios. Esto nos ayudará a seguir cada paso con más cuidado y ver que
sucede después de una modificación de la lista en particular.

Nota: todos los índices utilizados hasta ahora son literales. Sus valores se fijan en el
tiempo de ejecución, pero cualquier expresión también puede ser un índice. Esto abre
muchas posibilidades.

3.4.3 Acceso al contenido de las listas

Se puede acceder a cada uno de los elementos de la lista por separado. Por ejemplo, se
puede imprimir:

1 print(numbers[0]) # Accediendo al primer elemento de la lista.

2
 Suponiendo que todas las operaciones anteriores se hayan completado con éxito, el
fragmento enviará 111 a la consola.

  

1 numbers = [10, 5, 7, 2, 1]
2 print("Contenido de la lista original:", numbers) # Imprimiendo el contenido
3
4 numbers[0] = 111
5 print("\nContenido de la lista con cambio:", numbers) # Imprimiendo contenido
6
7 numbers[1] = numbers[4] # Copiando el valor del quinto elemento al segundo el
8 print("Contenido de la lista con intercambio:", numbers) # Imprimiendo conten
9
10 print("\nLongitud de la lista:", len(numbers)) # Imprimiendo la longitud de l
11

Console  

Como puedes ver en el editor, la lista también puede imprimirse como un todo - como
aquí:

1 print(numbers) # Imprimiendo la lista completa.

2

Como probablemente hayas notado antes, Python decora la output de una manera que
sugiere que todos los valores presentados forman una lista. La output del fragmento de
ejemplo anterior se ve así:

[111, 1, 7, 2, 1]
La 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).

Observa la última línea de código en el editor, ejecuta el programa y verifica que valor
imprimirá en la consola. ¿Puedes adivinar?

3.4.4 Eliminando elementos de una lista

Cualquier elemento de la lista puede ser eliminado en cualquier momento - esto se hace
con una instrucción llamada del (eliminar). Nota: es una instrucción, no una función.

Tienes que apuntar al elemento que quieres eliminar - desaparecerá de la lista y la

longitud de la lista se reducirá en uno.
 Mira el fragmento de abajo. ¿Puedes adivinar qué output producirá? Ejecuta el programa
en el editor y comprueba.

1 del numbers[1]
2 print(len(numbers))
3 print(numbers)
4

No puedes acceder a un elemento que no existe - no puedes obtener su valor ni

asignarle un valor. Ambas instrucciones causarán ahora errores de tiempo de ejecución:

1 print(numbers[4])
2 numbers[4] = 1
3

Agrega el fragmento de código anterior después de la última línea de código en el editor,

ejecuta el programa y verifica que sucede.

  

1 numbers = [10, 5, 7, 2, 1]
2 print("Contenido de la lista original:", numbers) # Imprimiendo el contenid
3
4 numbers[0] = 111
5 print("\nContenido de la lista con cambio:", numbers) # Imprimiendo conteni
6
7 numbers[1] = numbers[4] # Copiando el valor del quinto elemento al segundo
8 print("Contenido de la lista con intercambio:", numbers) # Imprimiendo cont
9
10 print("\nLongitud de la lista:", len(numbers)) # Imprimiendo la longitud de
11
12 ###
13
14 del numbers[1] # Eliminando el segundo elemento de la lista.
15 print("Longitud de la nueva lista:", len(numbers)) # Imprimiendo nueva long
Console  
Nota: hemos eliminado uno de los elementos de la lista - ahora solo hay cuatro elementos en la
lista. Esto significa que el elemento número cuatro no existe.

3.4.5 Los índices negativos son legales

Puede parecer extraño, pero los índices negativos son válidos, y pueden ser muy útiles.

Un elemento con un índice igual a -1 es el último en la lista.

  

1 numbers = [111, 7, 2, 1]
2 print(numbers[-1])
3

Console  
El código del ejemplo mostrará 1 . Ejecuta el programa y comprueba.

Del mismo modo, el elemento con un índice igual a -2 es el anterior al último en la lista.

  

1 numbers = [111, 7, 2, 1]
2 print(numbers[-2])
3

Console  

El fragmento de ejemplo dará como output un 2 .

El último elemento accesible en nuestra lista es numeros[-4] (el primero) - ¡no intentes ir más lejos!

LAB
3.4.6 LAB Los fundamentos de las
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).

¿Listo para este desafío?

  

1 hat_list = [1, 2, 3, 4, 5] # Esta es una lista existente de números ocultos e

2
3 # Paso 1: escribe una línea de código que solicite al usuario
4 # reemplazar el número de en medio con un número entero ingresado por el usuar
5
6 # Paso 2: escribe aquí una línea de código que elimine el último elemento de l
7
8 # Paso 3: escribe aquí una línea de código que imprima la longitud de la lista
9
10 print(hat_list)
11
12

Console  
 3.4.7 Funciones vs métodos

Un método es un tipo específico de función - se comporta como una función y se

parece a una función, pero difiere en la forma en que actúa y en su estilo de invocación.

Una función no pertenece a ningún dato - obtiene datos, puede crear nuevos datos y
(generalmente) produce un resultado.

Un método hace todas estas cosas, pero también puede cambiar el estado de una
entidad seleccionada.

Un método es propiedad de los datos para los que trabaja, mientras que una función
es propiedad de todo el código.

Esto también significa que invocar un método requiere alguna especificación de los
datos a partir de los cuales se invoca el método.

Puede parecer desconcertante aquí, pero lo trataremos en profundidad cuando

profundicemos en la programación orientada a objetos.

En general, una invocación de función típica puede tener este aspecto:

result = function(arg)
 La función toma un argumento, hace algo, y devuelve un resultado.

Una invocación de un método típico usualmente se ve así:

result = data.method(arg)

Nota: el nombre del método está precedido por el nombre de los datos que posee el
método. A continuación, se agrega un punto, seguido del nombre del método y un par
de paréntesis que encierran los argumentos.

El método se comportará como una función, pero puede hacer algo más - puede
cambiar el estado interno de los datos a partir de los cuales se ha invocado.

Puedes preguntar: ¿por qué estamos hablando de métodos, y no de listas?

Este es un tema esencial en este momento, ya que le mostraremos como agregar

nuevos elementos a una lista existente. Esto se puede hacer con métodos propios de las
listas, no por funciones.
 3.4.8 Agregando elementos a una lista:
append() y insert()

Un nuevo elemento puede ser añadido al final de la lista existente:

list.append(value)

Dicha operación se realiza mediante un método llamado append() . Toma el valor de su

argumento y lo coloca al final de la lista que posee el método.

La longitud de la lista aumenta en uno.

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.

list.insert(location, value)

Toma dos argumentos:

el primero muestra la ubicación requerida del elemento a insertar; nota: todos los
elementos existentes que ocupan ubicaciones a la derecha del nuevo elemento
(incluido el que está en la posición indicada) se desplazan a la derecha, para hacer
espacio para el nuevo elemento;
el segundo es el elemento a insertar.

Observa el código en el editor. Ve como usamos los métodos append() e insert() . Presta
atención a lo que sucede después de usar insert() : el primer elemento anterior ahora es el
segundo, el segundo el tercero, y así sucesivamente.
   

1 numbers = [111, 7, 2, 1]
2 print(len(numbers))
3 print(numbers)
4
5 ###
6
7 numbers.append(4)
8
9 print(len(numbers))
10 print(numbers)
11
12 ###
13
14 numbers.insert(0, 222)
Console  

Agrega el siguiente fragmento después de la última línea de código en el editor:

1 numbers.insert(1, 333)
2

Imprime el contenido de la lista final en la pantalla y ve que sucede. El fragmento de

código sobre el fragmento de código inserta 333 en la lista, por lo que es el segundo
elemento. El segundo elemento anterior se convierte en el tercero, el tercero en el
cuarto, y así sucesivamente.

Puedes iniciar la vida de una lista creándola vacía (esto se hace con un par de corchetes vacíos)
y luego agregar nuevos elementos según sea necesario.

Echa un vistazo al fragmento en el editor. Intenta adivinar su output después de la ejecución del
bucle for . Ejecuta el programa para comprobar si tenías razón.
   

1 my_list = [] # Creando una lista vacía.

2
3 for i in range(5):
4 my_list.append(i + 1)
5
6 print(my_list)
7

Console  

Será una secuencia de números enteros consecutivos del 1 (luego agrega uno a todos los valores
agregados) hasta 5 .

Hemos modificado un poco el fragmento:

1 my_list = [] # Creando una lista vacía.

2
3 for i in range(5):
4 my_list.insert(0, i + 1)
5
6 print(my_list)
7

¿Qué pasará ahora? Ejecuta el programa y comprueba si esta vez también tenías razón.

Deberías obtener la misma secuencia, pero en orden inverso (este es el mérito de usar
el método insert() ).
 3.4.9 Haciendo uso de las listas
El bucle for tiene una variante muy especial que puede procesar las listas de manera muy
efectiva - echemos un vistazo a eso.

  

1 my_list = [10, 1, 8, 3, 5]
2 total = 0
3
4 for i in range(len(my_list)):
5 total += my_list[i]
6
7 print(total)
8

Console  

Supongamos que deseas calcular la suma de todos los valores almacenados en la lista my_list .

Necesitas una variable cuya suma se almacenará y se le asignará inicialmente un valor de 0 - su

nombre será total . (Nota: no la vamos a nombrar sum ya que Python utiliza el mismo nombre para
una de sus funciones integradas: sum() . Utilizar ese nombre sería considerado una mala
práctica.) Luego agrega todos los elementos de la lista usando el bucle for . Echa un vistazo al
fragmento en el editor.

Comentemos este ejemplo:

a la lista se le asigna una secuencia de cinco valores enteros;

la variable i toma los valores 0 , 1 , 2 , 3 , y 4 , y luego indexa la lista, seleccionando los
elementos siguientes: el primero, segundo, tercero, cuarto y quinto;
cada uno de estos elementos se agrega junto con el operador += a la variable suma , dando
el resultado final al final del bucle;
observa la forma en que se ha empleado la función len() - hace que el código sea
independiente de cualquier posible cambio en el contenido de la lista.

El segundo aspecto del bucle for

Pero el bucle for puede hacer mucho más. Puede ocultar todas las acciones
conectadas a la indexación de la lista y entregar todos los elementos de la lista de
manera práctica.

Este fragmento modificado muestra como funciona:

1 my_list = [10, 1, 8, 3, 5]
2 total = 0
3
4 for i in my_list:
5 total += i
6
7 print(total)
8

¿Qué sucede aquí?

la instrucción for especifica la variable utilizada para navegar por la lista ( i )

seguida de la palabra clave in y el nombre de la lista siendo procesado ( my_list ).
a la variable i se le asignan los valores de todos los elementos de la lista
subsiguiente, y el proceso ocurre tantas veces como hay elementos en la lista;
esto significa que usa la variable i como una copia de los valores de los
elementos, y no necesita emplear índices;
 la función len() tampoco es necesaria aquí.

3.4.10 Listas en acción

Dejemos de lado las listas por un breve momento y veamos un tema intrigante.

Imagina que necesitas reorganizar los elementos de una lista, es decir, revertir el orden
de los elementos: el primero y el quinto, así como el segundo y cuarto elementos serán
intercambiados. El tercero permanecerá intacto.

Pregunta: ¿cómo se pueden intercambiar los valores de dos variables?

Echa un vistazo al fragmento:

1 variable_1 = 1
2 variable_2 = 2
3
4 variable_2 = variable_1
5 variable_1 = variable_2
6

Si haces algo como esto, perderás el valor previamente almacenado en variable_2 .

Cambiar el orden de las tareas no ayudará. Necesitas una tercera variable que sirva
como almacenamiento auxiliar.
 Así es como puedes hacerlo:

1 variable_1 = 1
2 variable_2 = 2
3
4 auxiliary = variable_1
5 variable_1 = variable_2
6 variable_2 = auxiliary
7

Python ofrece una forma más conveniente de hacer el intercambio - echa un vistazo:

1 variable_1 = 1
2 variable_2 = 2
3
4 variable_1, variable_2 = variable_2, variable_1
5

Claro, efectivo y elegante - ¿no?

Ahora puedes intercambiar fácilmente los elementos de la lista para revertir su orden:

1 my_list = [10, 1, 8, 3, 5]
2
3 my_list[0], my_list[4] = my_list[4], my_list[0]
4 my_list[1], my_list[3] = my_list[3], my_list[1]
5
6 print(my_list)
7
 Ejecuta el fragmento. Su output debería verse así:

Output
[5, 3, 8, 1, 10]

Se ve bien con cinco elementos.

¿Seguirá siendo aceptable con una lista que contenga 100 elementos? No, no lo hará.

¿Puedes usar el bucle for para hacer lo mismo automáticamente, independientemente

de la longitud de la lista? Si, si puedes.

Así es como lo hemos hecho:

1 for i in range(length // 2):

2 my_list[i], my_list[length - i - 1] = my_list[length - i - 1], my_list[i]
3
4 print(my_list)
5

Nota:

hemos asignado la variable length a la longitud de la lista actual (esto hace que
nuestro código sea un poco más claro y más corto)
hemos preparado el bucle for para que se ejecute su cuerpo length // 2 veces
(esto funciona bien para listas con longitudes pares e impares, porque cuando la
lista contiene un número impar de elementos, el del medio permanece intacto)
hemos intercambiado el elemento i (desde el principio de la lista) por el que tiene
un índice igual a (length - i - 1) (desde el final de la lista); en nuestro ejemplo, for
i igual a 0 a la (length - i - 1) da 4 ; for i igual a 3 , da 3 - esto es
exactamente lo que necesitábamos.

Las listas son extremadamente útiles y las encontrarás muy a menudo.

 LAB

3.4.11 LAB Los fundamentos de las

listas: los Beatles

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.

La 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).

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 bucle for 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.
Por cierto, ¿eres fan de los Beatles? (Los Beatles son una de las bandas favoritas de Greg. Pero
espera...¿Quién es Greg?)

  

1 # paso 1
2 print("Paso 1:", beatles)
3
4 # paso 2
5 print("Paso 2:", beatles)
6
7 # paso 3
8 print("Paso 3:", beatles)
9
10 # paso 4
11 print("Paso 4:", beatles)
12
13 # paso 5
14 print("Paso 5:", beatles)
Console  

3.4.12 RESUMEN DE SECCIÓN

 1. 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:

1 my_list = [1, None, True, "Soy una cadena", 256, 0]

2

2. Las listas se pueden indexar y actualizar, por ejemplo:

1 my_list = [1, None, True, 'Soy una cadena', 256, 0]

2 print(my_list[3]) # output: Soy una cadena
3 print(my_list[-1]) # output: 0
4
5 my_list[1] = '?'
6 print(my_list) # output: [1, '?', True, 'Soy una cadena', 256, 0]
7
8 my_list.insert(0, "primero")
9 my_list.append("último")
10 print(my_list) # output: ['primero', 1, '?', True, 'Soy una cadena', 256, 0,
11

3. Las listas pueden estar anidadas, por ejemplo:

1 my_list = [1, 'a', ["lista", 64, [0, 1], False]]

2

Aprenderás más sobre el anidamiento - por el momento, solo queremos que sepas que
algo como esto también es posible.

4. Los elementos de la lista y las listas se pueden eliminar, por ejemplo:

1 my_list = [1, 2, 3, 4]
2 del my_list[2]
3 print(my_list) # output: [1, 2, 4]
4
5 del my_list # borra la lista entera
6

Nuevamente, aprenderás más sobre esto - no te preocupes. Por el momento, intenta

experimentar con el código anterior y verifica cómo cambiarlo afecta la output.

5.Las listas pueden ser iteradas mediante el uso del bucle for , por ejemplo:

1 my_list = ["blanco", "purpura", "azul", "amarillo", "verde"]

2
3 for color in my_list:
4 print(color)
5

6. La función len() se puede usar para verificar la longitud de la lista, por ejemplo:

1 my_list = ["blanco", "purpura", "azul", "amarillo", "verde"]

2 print(len(my_list)) # output 5
3
4 del my_list[2]
5 print(len(my_list)) # output 4
6

7. Una invocación típica de función tiene el siguiente aspecto: result = function(arg) ,

mientras que una invocación típica de un método se ve así: result = data.method(arg) .
 3.4.13 QUIZ DE SECCIÓN

Pregunta 1: ¿Cuál es el resultado del siguiente fragmento de código?

1 lst = [1, 2, 3, 4, 5]
2 lst.insert(1, 6)
3 del lst[0]
4 lst.append(1)
5
6 print(lst)
7

Revisar

Pregunta 2: ¿Cuál es el resultado del siguiente fragmento de código?

1 lst = [1, 2, 3, 4, 5]
2 lst_2 = []
3 add = 0
4
5 for number in lst:
6 add += number
7 lst_2.append(add)
8
9 print(lst_2)
10

Revisar

Pregunta 3: ¿Cuál es el resultado del siguiente fragmento de código?

1 lst = []
2 del lst
3 print(lst)
4

Revisar

Pregunta 4: ¿Cuál es el resultado del siguiente fragmento de código?

1 lst = [1, [2, 3], 4]
2 print(lst[1])
3 print(len(lst))
4

Revisar
3.5 Sección 5 –
Ordenando listas
simples: el
ordenamiento de
burbuja

Deslizar para comenzar 

Bienvenido a la sección 5, donde aprenderás a cómo ordenar listas simples utilizando el
algoritmo de ordenamiento burbuja.

3.5.1 Ordenamiento Burbuja

Ahora que puedes hacer malabarismos con los elementos de las listas, es hora de
aprender como ordenarlos. Se han inventado muchos algoritmos de clasificación, que
difieren mucho en velocidad, así como en complejidad. Vamos a mostrar un algoritmo
muy simple, fácil de entender, pero desafortunadamente, tampoco es muy eficiente. Se
usa muy raramente, y ciertamente no para listas extensas.

Digamos que una lista se puede ordenar de dos maneras:

ascendente (o más precisamente - no descendente) - si en cada par de elementos

adyacentes, el primer elemento no es mayor que el segundo;
descendente (o más precisamente - no ascendente) - si en cada par de elementos
adyacentes, el primer elemento no es menor que el segundo.

En las siguientes secciones, ordenaremos la lista en orden ascendente, de modo que los
números se ordenen de menor a mayor.

Aquí está la lista:

 8 10 6 2 4

Intentaremos utilizar el siguiente enfoque: tomaremos el primer y el segundo elemento y

los compararemos; si determinamos que están en el orden incorrecto (es decir, el
primero es mayor que el segundo), los intercambiaremos; si su orden es válido, no
haremos nada. Un vistazo a nuestra lista confirma lo último - los elementos 01 y 02
están en el orden correcto, así como 8<10 .

Ahora observa el segundo y el tercer elemento. Están en las posiciones equivocadas.

Tenemos que intercambiarlos:

8 6 10 2 4

Vamos más allá y observemos los elementos tercero y cuarto. Una vez más, esto no es
lo que se supone que es. Tenemos que intercambiarlos:

8 6 2 10 4

Ahora comprobemos los elementos cuarto y quinto. Si, ellos también están en las
posiciones equivocadas. Ocurre otro intercambio:

8 6 2 4 10

El primer paso a través de la lista ya está terminado. Todavía estamos lejos de terminar
nuestro trabajo, pero algo curioso ha sucedido mientras tanto. El elemento más grande,
10 , ya ha llegado al final de la lista. Ten en cuenta que este es el lugar deseado para el.
Todos los elementos restantes forman un lío pintoresco, pero este ya está en su lugar.

Ahora, por un momento, intenta imaginar la lista de una manera ligeramente diferente -
es decir, de esta manera:

10

8
Observa - El 10 está en la parte superior. Podríamos decir que flotó desde el fondo
hasta la superficie, al igual que las burbujas en una copa de champán. El método de
clasificación deriva su nombre de la misma observación - se denomina ordenamiento
burbuja.

Ahora comenzamos con el segundo paso a través de la lista. Miramos el primer y el

segundo elemento - es necesario un intercambio:

6 8 2 4 10

Es hora del segundo y tercer elemento: también tenemos que intercambiarlos:

6 2 8 4 10

Ahora el tercer y cuarto elementos, y la segunda pasada, se completa, ya que 8 ya está

en su lugar:

6 2 4 8 10

Comenzamos el siguiente pase inmediatamente. Observa atentamente el primer y el

segundo elemento - se necesita otro cambio:

2 6 4 8 10

Ahora 6 necesita ir a su lugar. Cambiamos el segundo y el tercer elemento:

2 4 6 8 10

La lista ya está ordenada. No tenemos nada más que hacer. Esto es exactamente lo que
queremos.

Como puedes ver, la esencia de este algoritmo es simple: comparamos los elementos
adyacentes y, al intercambiar algunos de ellos, logramos nuestro objetivo.

Codifiquemos en Python todas las acciones realizadas durante un solo paso a través de
la lista, y luego consideraremos cuántos pases necesitamos para realizarlo. No hemos
explicado esto hasta ahora, pero lo haremos pronto.
 3.5.2 Ordenando una lista

¿Cuántos pases necesitamos para ordenar la lista completa?

Resolvamos este problema de la siguiente manera: introducimos otra variable, su tarea

es observar si se ha realizado algún intercambio durante el pase o no. Si no hay
intercambio, entonces la lista ya está ordenada, y no hay que hacer nada más. Creamos
una variable llamada swapped , y le asignamos un valor de False para indicar que no hay
intercambios. De lo contrario, se le asignará True .

1 my_list = [8, 10, 6, 2, 4] # lista a ordenar

2
3 for i in range(len(my_list) - 1): # necesitamos (5 - 1) comparaciones
4 if my_list[i] > my_list[i + 1]: # compara elementos adyacentes
5 my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i] # Si terminam
6

Deberías poder leer y comprender este programa sin ningún problema:

1 my_list = [8, 10, 6, 2, 4] # lista a ordenar

2 swapped = True # Lo necesitamos verdadero (True) para ingresar al bucle while
3
4 while swapped:
5 swapped = False # no hay intercambios hasta ahora
 6 for i in range(len(my_list) - 1):
7 if my_list[i] > my_list[i + 1]:
8 swapped = True # ¡ocurrió el intercambio!
9 my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]
10
11 print(my_list)
12

Ejecuta el programa y pruébalo.

  

Console  
 3.5.3 El ordenamiento burbuja – versión
interactiva
En el editor, puedes ver un programa completo, enriquecido por una conversación con el usuario, y
que permite ingresar e imprimir elementos de la lista: El ordenamiento burbuja - versión final
interactiva.

  

1 my_list = []
2 swapped = True
3 num = int(input("¿Cuántos elementos deseas ordenar?: "))
4
5 for i in range(num):
6 val = float(input("Ingresa un elemento de la lista: "))
7 my_list.append(val)
8
9 while swapped:
10 swapped = False
11 for i in range(len(my_list) - 1):
12 if my_list[i] > my_list[i + 1]:
13 swapped = True
14 my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]
Console  
Python, sin embargo, tiene sus propios mecanismos de clasificación. Nadie necesita escribir sus
propias clases, ya que hay un número suficiente de herramientas listas-para-usar.

Te explicamos este sistema de clasificación porque es importante aprender como procesar los
contenidos de una lista y mostrarte como puede funcionar la clasificación real.

Si quieres que Python ordene tu lista, puedes hacerlo de la siguiente manera:

1 my_list = [8, 10, 6, 2, 4]

2 my_list.sort()
3 print(my_list)
4

Es tan simple como eso.

La output del fragmento es la siguiente:

Output
[2, 4, 6, 8, 10]

Como puedes ver, todas las listas tienen un método denominado sort() , que las ordena
lo más rápido posible. Ya has aprendido acerca de algunos de los métodos de lista
anteriormente, y pronto aprenderás más sobre otros.
 3.5.4 RESUMEN DE SECCIÓN

1. Puedes usar el método sort() para ordenar los elementos de una lista, por ejemplo:

1 lst = [5, 3, 1, 2, 4]
2 print(lst)
3
4 lst.sort()
5 print(lst) # output: [1, 2, 3, 4, 5]
6

2.También hay un método de lista llamado reverse() , que puedes usar para invertir la
lista, por ejemplo:

1 lst = [5, 3, 1, 2, 4]
2 print(lst)
3
4 lst.reverse()
5 print(lst) # output: [4, 2, 1, 3, 5]
6
 3.5.5 QUIZ DE SECCIÓN

Pregunta 1: ¿Cuál es el resultado del siguiente fragmento de código?

1 lst = ["D", "F", "A", "Z"]

2 lst.sort()
3
4 print(lst)
5

Revisar

Pregunta 2: ¿Cuál es el resultado del siguiente fragmento de código?

1 a = 3
2 b = 1
3 c = 2
4
5 lst = [a, c, b]
6 lst.sort()
7
8 print(lst)
9

Revisar

Pregunta 3: ¿Cuál es el resultado del siguiente fragmento de código?

1 a = "A"
2 b = "B"
3 c = "C"
4 d = " "
5
6 lst = [a, b, c, d]
7 lst.reverse()
8
9 print(lst)
10

Revisar
 3.6 Sección 6 –
Operaciones con listas

Deslizar para comenzar 

En esta sección, aprenderás a cómo procesar listas utilizando rebanadas y los

operadores in y not in. También analizarás algunos programas simples que utilizan el
concepto de listas para aprender a aplicarlas en proyectos más desafiantes.
 3.6.1 La vida al interior de las listas
Ahora queremos mostrarte una característica importante y muy sorprendente de las listas, que las
distingue de las variables ordinarias.

Queremos que lo memorices - ya que puede afectar tus programas futuros y causar graves
problemas si se olvida o se pasa por alto.

Echa un vistazo al fragmento en el editor.

  

1 list_1 = [1]
2 list_2 = list_1
3 list_1[0] = 2
4 print(list_2)
5

Console  

El programa:

crea una lista de un elemento llamada list_1 ;

la asigna a una nueva lista llamada list_2 ;
cambia el único elemento de list_1 ;
imprime la list_2 ;
La parte sorprendente es el hecho de que el programa mostrará como resultado: [2] , no [1] ,
que parece ser la solución obvia.

Las listas (y muchas otras entidades complejas de Python) se almacenan de diferentes maneras
que las variables ordinarias (escalares).

Se podría decir 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.

Lee estas dos líneas una vez más - la diferencia es esencial para comprender de que vamos a
hablar a continuación.

La asignación: list_2 = list_1 copia el nombre del arreglo 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 uno de ellos afecta al otro, y viceversa.

¿Cómo te las arreglas con eso?

3.6.2 Rebanadas poderosas

Afortunadamente, la solución está al alcance de tu mano - su nombre es rebanada.

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.

 Esto es exactamente lo que necesitas. Echa un vistazo al fragmento de código a
continuación:

1 list_1 = [1]
2 list_2 = list_1[:]
3 list_1[0] = 2
4 print(list_2)
5

Su output es [1] .

Esta parte no visible del código descrito como [:] puede producir una lista
completamente nueva.

Una de las formas más generales de la rebanada es la siguiente:

my_list[inicio:fin]

Como puedes ver, se asemeja a la indexación, pero los dos puntos en el interior hacen
una gran diferencia.

Una rebanada de este tipo crea una nueva lista (de destino), tomando elementos de la
lista de origen - los elementos de los índices desde el start hasta el fin fin - 1 .

Nota: no hasta el fin sino hasta fin-1 . Un elemento con un índice igual a fin es el
primer elemento el cual no participa en la segmentación.

Es posible utilizar valores negativos tanto para el inicio como para el fin(al igual que en la
indexación).

Echa un vistazo al fragmento:

1 my_list = [10, 8, 6, 4, 2]
2 new_list = my_list[1:3]
 3 print(new_list)
4

La lista new_list contendrá fin - inicio (3 - 1 = 2) elementos ‒ los que tienen índices
iguales a 1 y 2 (pero no 3 ).

La output del fragmento es: [8, 6]

Ejecuta el código en el editor para ver cómo Python copia la lista completa y un
fragmento de la lista. ¡Siéntete libre de experimentar!

  

1 # Copiando la lista completa.

2 list_1 = [1]
3 list_2 = list_1[:]
4 list_1[0] = 2
5 print(list_2)
6
7 # Copiando parte de la lista.
8 my_list = [10, 8, 6, 4, 2]
9 new_list = my_list[1:3]
10 print(new_list)
11

Console  
 3.6.3 Rebanadas – índices negativos

Observa el fragmento de código a continuación:

my_list[start:end]

Para confirmar:

start es el índice del primer elemento incluido en la rebanada.

end es el índice del primer elemento no incluido en la rebanada.

Así es como los índices negativos funcionan en las rebanadas:

1 my_list = [10, 8, 6, 4, 2]
2 new_list = my_list[1:-1]
3 print(new_list)
4

El resultado del fragmento es:

Output
[8, 6, 4]

Si start especifica un elemento que se encuentra más allá del descrito por end (desde
 el punto de vista inicial de la lista), la rebanada estará vacía:

1 my_list = [10, 8, 6, 4, 2]
2 new_list = my_list[-1:1]
3 print(new_list)
4

La output del fragmento es:

Output
[]

Si omites el start en tu rebanada, se supone que deseas obtener un segmento que

comienza en el elemento con índice 0 .

En otras palabras, la rebanada sería de esta forma:

my_list[:end]

es un equivalente más compacto de:

my_list[0:end]

Observa el fragmento de código a continuación:

1 my_list = [10, 8, 6, 4, 2]
2 new_list = my_list[:3]
3 print(new_list)
4
 Es por esto que su output es: [10, 8, 6] .

Del mismo modo, si omites el end en tu rebanada, se supone que deseas que el
segmento termine en el elemento con el índice len(my_list) .

En otras palabras, la rebanada sería de esta forma:

my_list[start:]

es un equivalente más compacto de:

my_list[start:len(my_list)]

Observa el siguiente fragmento de código:

1 my_list = [10, 8, 6, 4, 2]
2 new_list = my_list[3:]
3 print(new_list)
4

Por lo tanto, la output es: [4, 2] .

Como hemos dicho anteriormente, el omitir el inicio y fin crea una copia de toda la
lista:

1 my_list = [10, 8, 6, 4, 2]
2 new_list = my_list[:]
3 print(new_list)
4

El resultado del fragmento es: [10, 8, 6, 4, 2] .

Más sobre la instrucción del

La instrucción del descrita anteriormente puede eliminar más de un elemento de la
lista a la vez - también puede eliminar rebanadas:

1 my_list = [10, 8, 6, 4, 2]
2 del my_list[1:3]
3 print(my_list)
4

Nota: En este caso, la rebanada ¡no produce ninguna lista nueva!

La output del fragmento es: [10, 4, 2] .

También es posible eliminar todos los elementos a la vez:

1 my_list = [10, 8, 6, 4, 2]
2 del my_list[:]
3 print(my_list)
4

La lista se queda vacía y la output es: [] .

Al eliminar la rebanada del código, su significado cambia dramáticamente.

 Echa un vistazo:

1 my_list = [10, 8, 6, 4, 2]
2 del my_list
3 print(my_list)
4

La instrucción del eliminará la lista, no su contenido.

La función print() de la última línea del código provocará un error de ejecución.

3.6.4 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:

1 elem in my_list
2 elem not in my_list
3

El primero de ellos ( in ) verifica si un elemento dado (el argumento izquierdo) está

actualmente almacenado en algún lugar dentro de la lista (el argumento derecho) - el
 operador devuelve True en este caso.

El segundo ( not in ) comprueba si un elemento dado (el argumento izquierdo) está

ausente en una lista - el operador devuelve True en este caso.

Observa el código en el editor. El fragmento muestra ambos operadores en acción. ¿Puedes

adivinar su output? Ejecuta el programa para comprobar si tenías razón.

  

1 my_list = [0, 3, 12, 8, 2]

2
3 print(5 in my_list)
4 print(5 not in my_list)
5 print(12 in my_list)
6
7

Console  
 3.6.5 Listas - algunos programas simples
Ahora queremos mostrarte algunos programas simples que utilizan listas.

El primero de ellos intenta encontrar el valor mayor en la lista. Mira el código en el editor.

  

1 my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]

2 largest = my_list[0]
3
4 for i in range(1, len(my_list)):
5 if my_list[i] > largest:
6 largest = my_list[i]
7
8 print(largest)
9

Console  
El concepto es bastante simple - asumimos temporalmente que el primer elemento es el más
grande y comparamos la hipótesis con todos los elementos restantes de la lista.

El código da como resultado el 17 (como se espera).

El código puede ser reescrito para hacer uso de la forma recién introducida del bucle
for :

1 my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]

2 largest = my_list[0]
3
4 for i in my_list:
5 if i > largest:
6 largest = i
7
8 print(largest)
9

El programa anterior realiza una comparación innecesaria, cuando el primer elemento se

compara consigo mismo, pero esto no es un problema en absoluto.

El código da como resultado el 17 también (nada inusual).

Si necesitas ahorrar energía de la computadora, puedes usar una rebanada:

1 my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]

2 largest = my_list[0]
3
4 for i in my_list[1:]:
5 if i > largest:
6 largest = i
7
8 print(largest)
9
 La pregunta es: ¿Cuál de estas dos acciones consume más recursos informáticos - solo
una comparación o rebanar casi todos los elementos de una lista?

Ahora encontremos la ubicación de un elemento dado dentro de una lista:

1 my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2 to_find = 5
3 found = False
4
5 for i in range(len(my_list)):
6 found = my_list[i] == to_find
7 if found:
8 break
9
10 if found:
11 print("Elemento encontrado en el índice", i)
12 else:
13 print("ausente")
14

Nota:

el valor buscado se almacena en la variable to_find ;

el estado actual de la búsqueda se almacena en la variable found ( True / False ).
cuando found se convierte en True , se sale del bucle for .

Supongamos que has elegido los siguientes números en la lotería: 3 , 7 , 11 , 42 , 34 ,

49 .

Los números que han salido sorteados son: 5 , 11 , 9 , 42 , 3 , y 49 .

La pregunta es: ¿A cuántos números le has atinado?

Este programa te dará la respuesta:

 1 drawn = [5, 11, 9, 42, 3, 49]
2 bets = [3, 7, 11, 42, 34, 49]
3 hits = 0
4
5 for number in bets:
6 if number in drawn:
7 hits += 1
8
9 print(hits)
10

Nota:

la lista drawn almacena todos los números sorteados;

La lista bets almacena los números con que se juega;
la variable hits cuenta tus aciertos.

la output del programa es: 4 .

LAB

3.6.6 LAB Operaciones con listas:

conceptos básicos
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.

Nota: Asume que la lista original está ya dentro del código - no tienes que ingresarla desde el
teclado. Por supuesto, puedes mejorar el código y agregar una parte que pueda llevar a cabo una
conversación con el usuario y obtener todos los datos.

Sugerencia: Te recomendamos que crees una nueva lista como área de trabajo temporal - no
necesitas actualizar la lista actual.

No hemos proporcionado datos de prueba, ya que sería demasiado fácil. Puedes usar nuestro
esqueleto en su lugar.

  

1 my_list = [1, 2, 4, 4, 1, 4, 2, 6, 2, 9]
2 #
3 # Escribe tu código aquí.
4 #
5 print("La lista con elementos únicos:")
6 print(my_list)
7
8

Console  
 3.6.7 RESUMEN DE SECCIÓN

1. Si tienes una lista list_1 , y la siguiente asignación: list_2 = list_1 esto no hace una
copia de la lista list_1 , pero hace que las variables list_1 y list_2 apunten a la
misma lista en la memoria. Por ejemplo:

1 vehicles_one = ['coche', 'bicicleta', 'motor']

2 print(vehicles_one) # output: ['coche', 'bicicleta', 'motor']
3
4 vehicles_two = vehicles_one
5 del vehicles_one[0] # elimina 'coche'
6 print(vehicles_two) # output: ['bicicleta', 'motor']
7

2. Si deseas copiar una lista o parte de la lista, puedes hacerlo haciendo uso de
rebanadas:

1 colors = ['rojo', 'verde', 'naranja']

2
3 copy_whole_colors = colors[:] # copia la lista entera
4 copy_part_colors = colors[0:2] # copia parte de la lista
5
 3. También puede utilizar índices negativos para hacer uso de rebanadas. Por ejemplo:

1 sample_list = ["A", "B", "C", "D", "E"]

2 new_list = sample_list[2:-1]
3 print(new_list) # output: ['C', 'D']
4

4. Los parámetros start y end son opcionales al partir en rebanadas una lista:
list[start:end] , por ejemplo:

1 my_list = [1, 2, 3, 4, 5]
2 slice_one = my_list[2: ]
3 slice_two = my_list[ :2]
4 slice_three = my_list[-2: ]
5
6 print(slice_one) # output: [3, 4, 5]
7 print(slice_two) # output: [1, 2]
8 print(slice_three) # output: [4, 5]
9

5. Puedes eliminar rebanadas utilizando la instrucción del :

1 my_list = [1, 2, 3, 4, 5]
2 del my_list[0:2]
3 print(my_list) # output: [3, 4, 5]
4
5 del my_list[:]
6 print(my_list) # elimina el contenido de la lista, genera: []
7

6. Puedes probar si algunos elementos existen en una lista o no utilizando las palabras
 clave in y not in , por ejemplo:

1 my_list = ["A", "B", 1, 2]

2
3 print("A" in my_list) # output: True
4 print("C" not in my_list) # output: True
5 print(2 not in my_list) # output: False
6

3.6.8 QUIZ DE SECCIÓN

Pregunta 1: ¿Cuál es el resultado del siguiente fragmento de código?

1 list_1 = ["A", "B", "C"]

2 list_2 = list_1
3 list_3 = list_2
4
5 del list_1[0]
6 del list_2[0]
7
8 print(list_3)
9
Revisar

Pregunta 2: ¿Cuál es el resultado del siguiente fragmento de código?

1 list_1 = ["A", "B", "C"]

2 list_2 = list_1
3 list_3 = list_2
4
5 del list_1[0]
6 del list_2
7
8 print(list_3)
9

Revisar

Pregunta 3: ¿Cuál es el resultado del siguiente fragmento de código?

1 list_1 = ["A", "B", "C"]

2 list_2 = list_1
3 list_3 = list_2
4
5 del list_1[0]
6 del list_2[:]
7
8 print(list_3)
9

Revisar

Pregunta 4: ¿Cuál es el resultado del siguiente fragmento de código?

1 list_1 = ["A", "B", "C"]

2 list_2 = list_1[:]
3 list_3 = list_2[:]
4
5 del list_1[0]
6 del list_2[0]
7
8 print(list_3)
9

Revisar

Pregunta 5: Inserta in o not in en lugar de ??? para que el código genere el resultado
esperado.

1 my_list = [1, 2, "in", True, "ABC"]

2
3 print(1 ??? my_list) # output True
4 print("A" ??? my_list) # output True
5 print(3 ??? my_list) # output True
6 print(False ??? my_list) # output False
7

Revisar
 3.7 Sección 7 – Listas en
aplicaciones avanzadas

Deslizar para comenzar 

En esta sección aprenderás sobre arreglos, listas anidadas (matrices) y listas por
comprensión.
 3.7.1 Listas dentro de listas

Las listas pueden constar de escalares (es decir, números) y elementos de una
estructura mucho más compleja (ya has visto ejemplos como cadenas, booleanos o
incluso otras listas en las lecciones del Resumen de la Sección anterior). Veamos más de
cerca el caso en el que los elementos de una lista son listas.

A menudo encontramos estos arreglos en nuestras vidas. Probablemente el mejor

ejemplo de esto sea un tablero de ajedrez.

Un tablero de ajedrez está compuesto de filas y columnas. Hay ocho filas y ocho
columnas. Cada columna está marcada con las letras de la A a la H. Cada línea está
marcada con un número del uno al ocho.

La ubicación de cada campo se identifica por pares de letras y dígitos. Por lo tanto,
sabemos que la esquina inferior derecha del tablero (la que tiene la torre blanca) es A1,
mientras que la esquina opuesta es H8.

Supongamos que podemos usar los números seleccionados para representar cualquier
pieza de ajedrez. También podemos asumir que cada fila en el tablero de ajedrez es
una lista.

Observa el siguiente código:

1 row = []
2
3 for i in range(8):
4 row.append(WHITE_PAWN)
5

Crea una lista que contiene ocho elementos que representan la segunda fila del tablero
de ajedrez: la que está llena de peones (supon que WHITE_PAWN es un símbolo
 predefinido que representa un peón blanco).

Comprensión de lista
El mismo efecto se puede lograr mediante una comprensión de lista, la sintaxis especial
utilizada por Python para completar o llenar listas masivas.

Una comprensión de lista es en realidad una lista, pero se creó sobre la marcha durante
la ejecución del programa, y no se describe de forma estática.

Echa un vistazo al fragmento:

1 row = [WHITE_PAWN for i in range(8)]

2

La parte del código colocada dentro de los paréntesis especifica:

los datos que se utilizarán para completar la lista ( WHITE_PAWN )

la cláusula que especifica cuántas veces se producen los datos dentro de la lista
( for i in range(8) )

Permítenos mostrarte otros ejemplos de comprensión de lista:

Ejemplo #1:

1 squares = [x ** 2 for x in range(10)]

2

El fragmento de código genera una lista de diez elementos y la rellena con cuadrados de
diez números enteros que comienzan desde cero (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

Ejemplo #2:
1 twos = [2 ** i for i in range(8)]
2

El fragmento crea un arreglo de ocho elementos que contiene las primeras ocho
potencias del numero dos (1, 2, 4, 8, 16, 32, 64, 128)

Ejemplo #3:

1 odds = [x for x in squares if x % 2 != 0 ]

2

El fragmento crea una lista con solo los elementos impares de la lista squares .

3.7.2 Arreglos de dos dimensiones

Supongamos también que un símbolo predefinido denominado EMPTY designa un

campo vacío en el tablero de ajedrez.

Entonces, si queremos crear una lista de listas que representan todo el tablero de
ajedrez, se puede hacer de la siguiente manera:

1 board = []
2
3 for i in range(8):
4 row = [EMPTY for i in range(8)]
5 board.append(row)
6

Nota:

la parte interior del bucle crea una fila que consta de ocho elementos (cada uno de
ellos es igual a EMPTY ) y lo agrega a la lista del board ;
la parte exterior se repite ocho veces;
en total, la lista board consta de 64 elementos (todos iguales a EMPTY ).

Este modelo imita perfectamente el tablero de ajedrez real, que en realidad es una lista
de elementos de ocho elementos, todos ellos en filas individuales. Resumamos nuestras
observaciones:

los elementos de las filas son campos, ocho de ellos por fila;
los elementos del tablero de ajedrez son filas, ocho de ellos por tablero de ajedrez.

La variable board ahora es un arreglo bidimensional. También se le llama, por analogía

a los términos algebraicos, una matriz.

Como las listas de comprensión puede ser anidadas, podemos acortar la creación del
tablero de la siguiente manera:

1 board = [[EMPTY for i in range(8)] for j in range(8)]

2

La parte interna crea una fila, y la parte externa crea una lista de filas.

El acceso al campo seleccionado del tablero requiere dos índices - el primero

selecciona la fila; el segundo - el número del campo dentro de la fila, el cual es un
número de columna.
 Echa un vistazo al tablero de ajedrez. Cada campo contiene un par de índices que se
deben dar para acceder al contenido del campo:

Echando un vistazo a la figura que se muestra arriba, coloquemos algunas piezas de

ajedrez en el tablero. Primero, agreguemos todas las torres:

1 board[0][0] = ROOK
 2 board[0][7] = ROOK
3 board[7][0] = ROOK
4 board[7][7] = ROOK
5

Si deseas agregar un caballo a C4, hazlo de la siguiente manera:

1 board[4][2] = KNIGHT
2

Y ahora un peón a E5:

1 board[3][4] = PAWN
2

Y ahora - experimenta con el código en el editor.

  

Console  
3.7.3 Naturaleza multidimensional de las
listas: aplicaciones avanzadas

Profundicemos en la naturaleza multidimensional de las listas. Para encontrar cualquier

elemento de una lista bidimensional, debes usar dos coordenadas:

Una vertical (número de fila).

Una horizontal (número de columna).

Imagina que desarrollas una pieza de software para una estación meteorológica
automática. El dispositivo registra la temperatura del aire cada hora y lo hace durante
todo el mes. Esto te da un total de 24 × 31 = 744 valores. Intentemos diseñar una lista
capaz de almacenar todos estos resultados.
 Primero, debes decidir qué tipo de datos sería adecuado para esta aplicación. En este
caso, sería mejor un float , ya que este termómetro puede medir la temperatura con una
precisión de 0.1 ℃.

Luego tomarás la decisión arbitraria de que las filas registrarán las lecturas cada hora
exactamente (por lo que la fila tendrá 24 elementos) y cada una de las filas se asignará a
un día del mes (supongamos que cada mes tiene 31 días, por lo que necesita 31 filas).
Aquí está el par apropiado de comprensiones ( h es para las horas, d para el día):

1 temps = [[0.0 for h in range(24)] for d in range(31)]

2

Toda la matriz está llena de ceros ahora. Puede suponer que se actualiza
automáticamente utilizando agentes de hardware especiales. Lo que tienes que hacer es
esperar a que la matriz se llene con las mediciones.

Ahora es el momento de determinar la temperatura promedio mensual del mediodía.

Suma las 31 lecturas registradas al mediodía y divida la suma por 31. Puedes suponer
que la temperatura de medianoche se almacena primero. Aquí está el código:

1 temps = [[0.0 for h in range(24)] for d in range(31)]

2 #
3 # La matriz se actualiza aquí.
4 #
5
6 total = 0.0
7
8 for day in temps:
9 total += day[11]
10
11 average = total / 31
12
13 print("Temperatura promedio al mediodía:", average)
14
 Nota: La variable day utilizada por el bucle for no es un escalar - cada paso a través de
la matriz temps lo asigna a la siguiente fila de la matriz; Por lo tanto, es una lista. Se debe
indexar con 11 para acceder al valor de temperatura medida al mediodía.

Ahora encuentra la temperatura más alta durante todo el mes - analiza el código:

1 temps = [[0.0 for h in range(24)] for d in range(31)]

2 #
3 # La matriz se actualiza aquí.
4 #
5
6 highest = -100.0
7
8 for day in temps:
9 for temp in day:
10 if temp > highest:
11 highest = temp
12
13 print("La temperatura más alta fue:", highest)
14

Note:

la variable day itera en todas las filas de la matriz temps ;

la variable temp itera a través de todas las mediciones tomadas en un día.

Ahora cuenta los días en que la temperatura al mediodía fue de al menos 20 ℃:

1 temps = [[0.0 for h in range(24)] for d in range(31)]

2 #
3 # La matriz se actualiza aquí.
4 #
5
6 hot_days = 0
7
8 for day in temps:
9 if day[11] > 20.0:
10 hot_days += 1
11
12 print(hot_days, "fueron los días calurosos.")
13

Python no limita la profundidad de la inclusión lista en lista. Aquí puedes ver un ejemplo
de un arreglo tridimensional:

1 rooms = [[[False for r in range(20)] for f in range(15)] for t in range(3)]

2

Imagina un hotel. Es un hotel enorme que consta de tres edificios, de 15 pisos cada uno.
Hay 20 habitaciones en cada piso. Para esto, necesitas un arreglo que pueda recopilar y
procesar información sobre las habitaciones ocupadas/libres.

Primer paso - El tipo de elementos del arreglo. En este caso, sería un valor Booleano
( True / False ).

Paso dos - análisis de la situación. Resume la información disponible: tres edificios, 15

pisos, 20 habitaciones.
 Ahora puedes crear el arreglo:

1 rooms = [[[False for r in range(20)] for f in range(15)] for t in range(3)]

2

El primer índice ( 0 a 2 ) selecciona uno de los edificios; el segundo ( 0 a 14 )

selecciona el piso, el tercero ( 0 a 19 ) selecciona el número de habitación. Todas las
habitaciones están inicialmente desocupadas.

Ahora ya puedes reservar una habitación para dos recién casados: en el segundo
edificio, en el décimo piso, habitación 14:

1 rooms[1][9][13] = True
2

y desocupar el segundo cuarto en el quinto piso ubicado en el primer edificio:

1 rooms[0][4][1] = False
2

Verifica si hay disponibilidad en el piso 15 del tercer edificio:

1 vacancy = 0
2
3 for room_number in range(20):
4 if not rooms[2][14][room_number]:
5 vacancy += 1
6
 La variable vacancy contiene 0 si todas las habitaciones están ocupadas, o en dado
caso el número de habitaciones disponibles.

¡Felicitaciones! Has llegado al final del módulo. ¡Sigue con el buen trabajo!

3.7.4 RESUMEN DE SECCIÓN

1. La comprensión de listas te permite crear nuevas listas a partir de las existentes de

una manera concisa y elegante. La sintaxis de una comprensión de lista es la siguiente:

[expresión para el elemento en la lista si es condicional]

El cual es un equivalente del siguiente código:

for element in list:

if conditional:
expression
 Este es un ejemplo de una comprensión de lista - el código siguiente crea una lista de
cinco elementos con los primeros cinco números naturales elevados a la potencia de 3:

1 cubed = [num ** 3 for num in range(5)]

2 print(cubed) # output: [0, 1, 8, 27, 64]
3

2. Puedes usar listas anidadas en Python para crear matrices (es decir, listas
bidimensionales). Por ejemplo:
1 # Una tabla de cuatro columnas y cuatro filas: un arreglo bidimensional (4x4)
2
3 table = [[":(", ":)", ":(", ":)"],
4 [":)", ":(", ":)", ":)"],
5 [":(", ":)", ":)", ":("],
6 [":)", ":)", ":)", ":("]]
7
8 print(table)
9 print(table[0][0]) # output: ':('
10 print(table[0][3]) # output: ':)'
11
 3. Puedes anidar tantas listas en las listas como desee y, por lo tanto, crear listas n-
dimensionales, por ejemplo, arreglos de tres, cuatro o incluso sesenta y cuatro
dimensiones. Por ejemplo:

1 # Cubo - un arreglo tridimensional (3x3x3)

2
3 cube = [[[':(', 'x', 'x'],
4 [':)', 'x', 'x'],
5 [':(', 'x', 'x']],
6
7 [[':)', 'x', 'x'],
8 [':(', 'x', 'x'],
9 [':)', 'x', 'x']],
10
11 [[':(', 'x', 'x'],
12 [':)', 'x', 'x'],
13 [':)', 'x', 'x']]]
14
15 print(cube)
16 print(cube[0][0][0]) # output: ':('
17 print(cube[2][2][0]) # output: ':)'
18
 3.8 Módulo 3 Finalización
- Prueba del Módulo

Deslizar para comenzar 

PRUEBA MÓDULO 3

¡Bien hecho! Has llegado al final del Módulo 3 y has completado una meta importante en
tu educación de programación en Python. He aquí un breve resumen de los objetivos
que has cubierto y con lo que te has familiarizado en el Módulo 3:

Valores booleanos para comparar diferentes valores y controlar las rutas de

ejecución usando las instrucciones if e if-else;
 la utilización de bucles (while and for) y cómo controlar su comportamiento
utilizando las instrucciones break y continue;
la diferencia entre operaciones lógicas y bit a bit;
el concepto de listas y procesamiento de listas, incluyendo la iteración
proporcionada por el bucle for loop, y las rebanadas;
la idea de los arreglos multidimensionales.

Ahora estás listo para tomar la Prueba del Módulo, que te ayudará a evaluar lo que has
aprendido hasta ahora.

La siguiente prueba se basa en lo que acabas de aprender. Hay veinte preguntas en total
y debes obtener al menos un 70% para aprobar.

¡Buena suerte!

Pregunta 1
Un operador que puede verificar si dos valores son iguales se codifica como:

 ==

=
 ===

!=

Pregunta 2
El valor asignado finalmente a x es igual a:

1 x = 1
2 x = x == x
3

 True

False

1
 Pregunta 3
¿Cuántos ( * ) enviará el siguiente fragmento de código a la consola?

1 i = 0
2 while i <= 3 :
3 i += 2
4 print("*")
5

 2

Pregunta 4
 ¿Cuántos ( * ) enviará el siguiente fragmento de código a la consola?

1 i = 0
2 while i <= 5 :
3 i += 1
4 if i % 2 == 0:
5 break
6 print("*")
7

 1

Pregunta 5
¿Cuántos ( # ) enviará el siguiente fragmento de código a la consola?

1 for i in range(1):
2 print("#")
3 else:
4 print("#")
5

 0

Pregunta 6
¿Cuántos ( # ) enviará el siguiente fragmento de código a la consola?

1 var = 0
2 while var < 6:
3 var += 1
4 if var % 2 == 0:
5 continue
6 print("#")
7

 3
 0

Pregunta 7
¿Cuántos ( # ) enviará el siguiente fragmento de código a la consola?

1 var = 1
2 while var < 10:
3 print("#")
4 var = var << 1
5

 4

2
 8

Pregunta 8
¿Qué valor será asignado a la variable x ?

1 z = 10
2 y = 0
3 x = y < z and z > y or y > z and z < y
4

 True

False

0
 Pregunta 9
¿Cuál es la output del siguiente fragmento de código?

1 a = 1
2 b = 0
3 c = a & b
4 d = a | b
5 e = a ^ b
6
7 print(c + d + e)
8

 2

Pregunta 10
¿Cuál es la output del siguiente fragmento de código?

1 my_list = [3, 1, -2]

2 print(my_list[my_list[-1]])
3

 1

-2

-1

Pregunta 11
¿Cuál es la output del siguiente fragmento de código?

1 my_list = [1, 2, 3, 4]
2 print(my_list[-3:-2])
3

 [2]

[]
 [2, 3]

[2, 3, 4]

Pregunta 12
La segunda asignación:

1 vals = [0, 1, 2]
2 vals[0], vals[2] = vals[2], vals[0]
3

 invierte la lista

acorta la lista

extiende la lista

mantiene la lista igual

 Pregunta 13
Después de la ejecución del siguiente fragmento de código, la suma de todos los
elementos vals será igual a:

1 vals = [0, 1, 2]
2 vals.insert(0, 1)
3 del vals[1]
4

 4

Pregunta 14
 Observa el código, y selecciona las sentencias verdaderas: (Selecciona dos
respuestas)

1 nums = [1, 2, 3]
2 vals = nums
3 del vals[1:2]
4

 nums y vals son de la misma longitud

nums es más larga que vals

 nums es replicada y asignada a vals

nums y vals se refieren a la misma lista

Pregunta 15
¿Cuáles de los siguientes enunciados son verdaderos? (Selecciona dos respuestas)

1 nums = [1, 2, 3]
2 vals = nums[-1:-2]
3
  nums es más larga que vals

nums y vals son de la misma longitud

vals es más larga que nums

 nums y vals son dos listas diferentes

Pregunta 16
¿Cuál es la output del siguiente fragmento de código?

1 my_list_1 = [1, 2, 3]
2 my_list_2 = []
3 for v in my_list_1:
4 my_list_2.insert(0, v)
5 print(my_list_2)
6

 [3, 2, 1]

[1, 2, 3]
 [1, 1, 1]

[3, 3, 3]

Pregunta 17
¿Cuál es la output del siguiente fragmento de código?

1 my_list = [1, 2, 3]
2 for v in range(len(my_list)):
3 my_list.insert(1, my_list[v])
4 print(my_list)
5

[1, 1, 1, 1, 2, 3]

 [1, 2, 3, 3, 2, 1]

[1, 2, 3, 1, 2, 3]

[3, 2, 1, 1, 2, 3]
 Pregunta 18
¿Cuántos elementos contiene la lista my_list ?

1 my_list = [i for i in range(-1, 2)]

2

 3

Pregunta 19
¿Cuál es la output del siguiente fragmento de código?

1 t = [[3-i for i in range (3)] for j in range (3)]

2 s = 0
3 for i in range(3):
4 s += t[i][i]
5 print(s)
6

 6

Pregunta 20
¿Cuál es la output del siguiente fragmento de código?

1 my_list = [[0, 1, 2, 3] for i in range(2)]

2 print(my_list[2][0])
3

 el fragmento generará un error de ejecución

0

¡Has enviado tus respuestas!

Reiniciar


Evaluación de Revisión
 85%
Has obtenido 85%.

Felicidades, has acreditado el quiz.