TUTORIAL 2

Lenguaje de programación: Python

Autor: José Gerardo Carrillo González

Contenido:
Escribir código...................................................................................................................................2
Indentación.....................................................................................................................................2
Imprimir en pantalla.......................................................................................................................2
Capturar una cadena.......................................................................................................................5
Sentencia If........................................................................................................................................5
Ejemplo 1.......................................................................................................................................6
Sentencia While.................................................................................................................................6
Ejemplo 2.......................................................................................................................................7
Ejemplo 3.......................................................................................................................................8
Ejemplo 4.......................................................................................................................................9
Ejemplo 5.......................................................................................................................................9
Ejemplo 6.....................................................................................................................................10
Ejemplo 7.....................................................................................................................................11
Ejemplo 8.....................................................................................................................................12
Sentencia For...................................................................................................................................14
Ejemplo 9.....................................................................................................................................15
Ejemplo 10...................................................................................................................................18
Ejemplo 11...................................................................................................................................19
Ejemplo 12...................................................................................................................................19
Ejemplo 13...................................................................................................................................20
Ejemplo 14...................................................................................................................................21
Tarea................................................................................................................................................23
Tarea 1.........................................................................................................................................23
Tarea 2.........................................................................................................................................23
Tarea 3.........................................................................................................................................23
Tarea 4.........................................................................................................................................24
Referencias.......................................................................................................................................24

1
Escribir código

Para escribir un código lo podemos hacer en un editor de texto cualquiera, o bien en la

ventana IDLE Shell accedemos a File, New file, y nos aparece la ventana de la Figura 1.

Figura 1.

En la ventana anterior podemos escribir código. Este lo guardaremos con extensión .py
(Python files) y lo podemos ejecutar seleccionando la pestaña Run, Run Module, o
directamente presionando F5.

Indentación

El bloque que comprende las instrucciones de una función, de una clase, sentencia if, ciclo
for o while debe estar indentado, es decir, se debe dejar el mismo número de espacios al
inicio de cada renglón que comprende el bloque. La indentación es la forma en la que
Python agrupa instrucciones. Ejemplo:

Se dejaron 4 espacios en la línea 2 (única instrucción del bloque if) y se dejaron 4 espacios
en la línea 4 (única instrucción del bloque else).

Imprimir en pantalla

La función print se usa para imprimir en pantalla texto y valores. La manera mas sencilla de
usarlo la podemos ver en el siguiente ejemplo

2
>>> nombre='Sol'
>>> print('Buenos días ', nombre, '. ¿Cómo estás?', sep='')
Buenos días Sol. ¿Cómo estás?

Como podemos ver en la sintaxis separamos cadenas y variables por medio de una coma,
en la salida que vemos en pantalla el separador entre valores sería el que especifiquemos
con el parámetro sep, que en este ejemplo es sin separador porque dentro de las comillas
tenemos nada.

Otra manera de usar la función print sería con la siguiente sintaxis

print( 'cadena {}, {},…,{} '.format(variable_1, variable_2,…, variable_x) )

Donde 'cadena {}' es el texto que mostraremos, aquí pondremos llaves en donde vayan
valores. Luego variable_1, variable_2, …, variable_x son los nombres que deben coincidir
con el orden que se escribieron las llaves, por lo que el número de llaves debe ser igual que
el número de nombres. Ejemplo

Salida en pantalla:
El lunes trabaje, el domingo descanse.

También es posible escoger el índice de la posición de los valores, esta inicia de izquierda a
derecha iniciando en cero. El índice se coloca dentro de las llaves. Ejemplo

Salida en pantalla:
En el año 2002 me fue bien, pero en el 2004 no.

Si tenemos un objeto de clase diccionario se puede escribir en las llaves la clave y al

imprimir en pantalla veremos el valor asociado a dicha clave. En este caso la sintaxis es

print( 'cadena {}'.format(**diccionario) )

Siendo diccionario un diccionario cualquiera con la restricción de que las claves no pueden
ser números o cadenas con solo números Ejemplo

Salida en pantalla:
El automóvil es marca Toyota, modelo Corolla, del año 2009.

3
Otra manera de combinar texto y valores es lo que se conoce como f-string (formatted
string literals), que lo podríamos traducir al español como cadenas literales con formato.
Para esto escribimos una f fuera de las comillas y entre llaves los nombres de las variables.
Ejemplo

Salida en pantalla:
Este año trabajé 330 días y descansé 35 días.

Ya que f-string es una expresión que se evalúa en tiempo de ejecución esto nos permite
hacer operaciones dentro de la llaves, o incluso llamar una función. Ejemplo

Salida en pantalla:
El resultado es 18
El resultado es 18

Para imprimir en pantalla se puede escribir en varias líneas lo que se desea mostrar:

Salida en pantalla:
El automóvil es marca Toyota. Modelo Corolla. Del año 2009.

De manera opcional se puede escoger un especificador de formato. Con {n1:.3f}

redondeamos n1 a tres decimales después del punto. Ejemplo

Salida:
pi redondeado a tres decimales es 3.142

Con {nombre:x}, el espacio en pantalla donde aparecerá el valor al que hace referencia
nombre tendrá un número mínimo de posiciones igual a x, si la longitud del objeto es
mayor que x entonces el número de posiciones se extiende a dicha longitud. Para alinear a
la izquierda, derecha, al centro, se hace con <, >, y ^, respectivamente. Ejemplo
4
Salida:

Capturar una cadena

Para capturar una cadena se hace por medio de la función input. La sintaxis para usar esta
función es

nombre=input('cadena')

Se tiene que nombre es un nombre cualquiera para referenciar el valor capturado (que será
de tipo str), 'cadena' es el texto que se va a desplegar previo a la captura. Cuando
presionamos enter se vincula nombre con la cadena que se haya escrito. Ejemplo

>>> valor=input('Escribe un valor: ')

Escribe un valor: 12
>>> valor
'12'
>>> type(valor)
<class 'str'>

Sentencia If
La sentencia if se usa para ejecutar un bloque de código, una vez, si la condición resulta
True. La estructura de la sentencia if es:

if (condición):
bloque de código
elif (condición):
bloque de código
else:
bloque de código

5
Si la condición del if resulta False, se puede usar la sentencia elif (que lleva condición) para
ejecutar su respectivo bloque de código si su condición da True, si la condición de este (o
estos, porque se puede tener más de uno) resulta(n) false se puede usar la sentencia else
(que no lleva condición) para ejecutar su respectivo bloque de código. Si la condición del if
da True, la(s) sentencia(s) elif y else se ignoran. Si la condición del if es false, al resultar
True la condición de una sentencia elif se ejecuta su respectivo bloque de código y se
ignoran los siguientes elif y el else. Si la condición del if y la(s) condición(es) de la(s)
sentencia(s) elif resultan False, se ejecuta el bloque de código de la sentencia else. Podemos
usar la sentencia if por si sola, if en combinación con elif (uno o varios), if en combinación
con else, y como se describió en la estructura se puede usar if en combinación con elif (uno
o varios) y else.

Ejemplo 1

Indicarle al usuario que escriba un número entero e imprimir en pantalla si es positivo,

negativo, o cero.

En Línea 1 por medio de la función input se muestra una cadena en la que se pide introducir
un número entero, con la cadena capturada creamos una instancia de la clase int y la
vinculamos con x. En línea 3 tenemos un if, si su condición se cumple, es decir si x<0 se
ejecuta su bloque de instrucciones (la línea 4) y pasamos a la línea 9 (no hay más
instrucciones por lo que el código termina). En la línea 5 tenemos un elif que tiene por
condición x>0, de dar True se ejecuta su bloque de instrucciones (la línea 6) y pasamos a la
línea 9 (no hay más instrucciones por lo que el código termina). En la línea 7 tenemos la
sentencia else, no tiene condición por lo que su bloque de instrucciones (la línea 8) se
ejecuta si la condición del if (en línea 3) y la condición del elif (en línea 5) dan False.
Además, si se llegó al else es porque x hace referencia a un número entero que cumple con
0 ≤ x ≤ 0, por lo que x hace referencia a un cero.

Sentencia While
La estructura del while es:

while (condición):
bloque de código

6
else:
bloque de código

La sentencia while la usaremos para hacer que su bloque de código (indentado) se ejecute
(repetidamente) mientras que la condición se evalué True, si se evalúa False el bloque no se
ejecutará y el ciclo while se da por finalizado. La condición la definiremos como una
expresión que se reduce a un valor de dos posibles: True o False. Con la condición se tiene
control de las veces que se repetirá el bloque de código.
Cada línea que conforma el bloque del while debe estar indentado (en inglés, indentation).
La indentación se usa para agrupar un conjunto de instrucciones (el bloque); en cada línea
de un bloque se debe dejar la misma cantidad de espacios y esa cantidad debe ser mayor o
igual a uno. Se pueden tener bloques anidados, es decir, un bloque dentro de un bloque,
pero el bloque más interno debe tener más espacios que el bloque inmediato exterior, y así
sucesivamente.

Ejemplo 2

Imprimir en pantalla los números del 1 al 9 usando la sentencia while.

En línea 1 definimos dos variables, el orden en que aparecen las variables de izquierda a
derecha (separadas por coma) es el orden con que se vinculan con los valores a la derecha
del operador de asignación; por lo que inicio hace referencia a 1 y fin a 10. En línea 2
tenemos la sentencia while y enseguida la condición (inicio < fin). El bloque de
instrucciones del while está indentado, es decir, se dejó el mismo número de espacios al
inicio de las líneas 3 y 4, el bloque se ejecutará una y otra vez mientras la condición se
evalúe True. Para ejecutar el programa primero se guarda, para esto damos clic en la
pestaña File, luego Save As, luego escogemos la ubicación para guardarlo y un nombre. El
archivo debe tener extensión .py. Para ejecutarlo vamos a la pestaña Run, luego Run
Module. En la ventana IDLE Shell vemos la salida:

1
2
3
4
5
6
7
8
9

7
En la línea 4 tenemos punto y coma al final, que se puede poner para finalizar una
instrucción. Se pueden tener varias instrucciones en una misma línea siempre y cuando
estén separadas por punto y coma. La primera vez que la condición del while se evalúa se
reduce a inicio<fin=1<10=True, por lo que se ejecutan las líneas 3 y 4. La línea 3 es para
imprimir en pantalla el valor de inicio y la línea 4 es para incrementar el valor de inicio en
uno, que también se puedo lograr con inicio+=1. En la siguiente iteración la condición
2<10=True, y así sucesivamente hasta que 10<10=False, el bloque del while no se ejecuta y
ya que fuera del bloque no siguen más instrucciones, el programa finaliza. Para escribir una
condición tenemos los operadores de comparación: menor que (<), mayor que (>), menor o
igual que (<=), mayor o igual que (>=), igual que (==), diferente que ( !=); los operadores
lógicos: and, or, not; los operadores de membresía: in, not in; los operadores de identidad:
is, is not.

Ejemplo 3

Verificar que un número introducido por el usuario esté en el rango [1,10].

En la línea 1 tenemos:

n1=int(input('Introduce un número entre 1 y 10: '))

La función input('string') se usa para capturar un objeto de tipo str que el usuario escribe
con el teclado, la función muestra en pantalla la cadena dentro de los paréntesis (la cadena
es opcional), luego espera a que el usuario escriba algo con el teclado (opcionalmente) y
presione ENTER. En el Ejemplo 2 con la línea 1 la cadena mostrada es: 'Introduce un
número entre 1 y 10: ', luego con la cadena introducida por el usuario creamos una instancia
de la clase int (ver referencia [1]) y la referenciamos con n1. En línea 3 tenemos la
sentencia while, las líneas 4 y 5 conforman su bloque de instrucciones. La condición del
while es ((n1<1) or (n1>10)) y se lee: si n1 es menor que 1 o si n1 es mayor que 10; si la
condición se evalúa True significa que n1 no está en el rango que se solicitó (recordemos la
cadena 'Introduce un número entre 1 y 10: ') y se ejecuta el bloque de instrucciones del
while. Notar que el operador lógico or es para obtener True ya sea que n1<1 o que n1>10.
En línea 4 tenemos

print('El', n1, 'no está en el rango correcto, introduce otro número:')

8
La función print se usa para imprimir en pantalla valores referenciados por nombres y
cadenas; la línea 4 es para imprimir en pantalla que el número introducido no está en el
rango correcto y para solicitar otro número. En la línea 5 se usa nuevamente la función
input, esta vez sin argumento, es decir, sin la cadena que se mostraría; con la cadena que
introduce el usuario creamos una instancia de la clase int y la vinculamos con n1. La
siguiente iteración del while sucede o no dependiendo del valor actual de n1. La condición
del while se evalúa False cuando el número referenciado por n1 satisface la condición
1<=n1<=10, de ser así finaliza el while por lo que no se ejecutan las líneas 4 y 5, es decir,
no se ejecuta el bloque del while y pasamos a la siguiente línea fuera del bloque, a la línea 7
en la cual con la función print se da a conocer el valor de n1.

Ejemplo 4

Imprimir en pantalla la tabla de multiplicar del 1 al 10 para un número en el rango [1,10].

En línea 1 con la función input obtenemos un str, con este valor creamos una instancia de la
clase int que referenciaremos con n1, dicho valor es el número del cual se desea imprimir la
tabla de multiplicar. A n1 lo multiplicaremos por cada número entero entre 1 y 10, por lo
que definimos n2=1. La condición del while en línea 6, que es (n2<=10), mientras se evalúe
True se ejecuta el bloque de instrucciones que comprende las líneas 7 y 8. La línea 7 es
para imprimir en pantalla el resultado de multiplicar n1 por n2. En línea 8 tenemos n2+=1,
para al valor actual de n2 sumarle un 1 y el resultado vincularlo con n2. Cuando n2=11, la
condición del while se evalúa False y lo finaliza. Notar en línea 4 que en la función print
escribimos \n, esta combinación de caracteres se usa para hacer un cambio de línea.

Ejemplo 5

Imprimir en pantalla los números pares en el rango [1,100].

9
La condición del while en línea 3, es decir 0=¿ 0, se evalúa siempre True, por lo que el
bloque de instrucciones de la línea 4 a la 12 se ejecutara una y otra vez; una manera
alternativa de finalizar un while, que no sea porque su condición se evalúe False, es
mediante la sentencia break. En línea 5 incrementamos n1 en una unidad. En línea 6 se
tiene un if que tiene por condición n1>n2, cuando resulte True (que será cuando 101>100)
se ejecuta la línea 7, en la cual la sentencia break finaliza el while, por lo que el resto de las
instrucciones del bloque del while (líneas 9 a 12) ya no se ejecutaran. El if en línea 9 lo que
se hace es comprobar si n1 es par o impar, si la condición n 1 % 2 !=0 resulta True, se tiene
que n1 es impar (ya que al dividirlo entre 2 el residuo es diferente que 0) y se ejecuta la
línea 10; la sentencia continue es para interrumpir la iteración actual de un ciclo while (o de
un ciclo for) y pasar a la siguiente iteración. Cuando la condición en línea 9 resulta False (al
dividir n1 entre 2 el residuo es cero) es porque n1 es par, entonces se ejecuta la línea 12 que
es para imprimir en pantalla el valor de n1. Al ejecutar el código vemos en pantalla los
números pares entre 1 y 100.

Ejemplo 6

Determinar el número de veces que la letra a, minúscula o mayúscula, se repite en una

cadena introducida por el usuario.

En línea 1 con la función input capturamos una cadena que será introducida por el usuario,
está por defecto será un objeto de tipo str y la vinculamos con palabra. En línea 2

10
obtenemos el número de caracteres del valor del objeto al que hace referencia palabra y lo
asignamos en longitud. En la línea 3 inicializamos dos contadores en cero, i lo usaremos
como índice para acceder a cada carácter de palabra y j para contar las veces que se repite
la letra a. En línea 5 tenemos una sentencia while con condición i<longitud; en línea 10
incrementamos i en una unidad, entonces cuando i>=longitud el ciclo while finaliza, por lo
que el número de iteraciones que sucederán es igual al número de caracteres de palabra. El
bloque de instrucciones del while comprende de la línea 6 a la 10. En la línea 7 se tiene una
sentencia if con condición (palabra[i]=='a' or palabra[i]=='A'), con esta condición se
determina si el carácter en la posición i de palabra es igual al carácter 'a' o al carácter 'A',
de ser así la condición da True y se ejecuta la línea 8, que es para incrementar el valor
actual de j en una unidad, por lo que j lleva la cuenta de las veces que se ha repetido el
carácter 'a' o al carácter 'A'. En línea 11 tenemos una sentencia else, esta se usa para que
cuando la condición del while sea False el bloque de instrucciones del else se ejecute una
vez, en este caso el bloque del else es únicamente la línea 12 y es para imprimir en pantalla
el valor de j. Nota: no se ejecuta el bloque de instrucciones del else si el while es finalizado
por medio de la sentencia break.

Ejemplo 7

Agregar en una lista cinco calificaciones introducidas por el usuario y que estén en el rango
[0, 100]. Sacar el promedio de las calificaciones.

En línea 1 tenemos tres instrucciones separadas por punto y coma, cada una para definir
una variable: i=0; suma=0; lista1=[]. Con i llevaremos la cuenta de las calificaciones
introducidas correctamente, además puede ser el índice de lista1. Con suma llevaremos la
sumatoria de las calificaciones. En lista1 (que se definió como una lista vacía) agregaremos
las calificaciones. El bloque de instrucciones (líneas de la 4 a la 11) del ciclo while (en
línea 3) se ejecuta siempre que la condición (i<5) resulte True. En línea 4 con la función
input capturamos una calificación (que puede tener punto decimal y decimales), con este
dato (un str) creamos un objeto de clase float y lo vinculamos con n. En línea 6 tenemos un
if con condición ((n<0) or (n>100)), esta condición da True si la calificación no está en el
rango correcto, de ser así se ejecuta la instrucción en línea 7 que es para imprimir en

11
pantalla que la calificación no está entre 0 y 100. Si la condición del if da False la
calificación está en el rango correcto y se ejecuta el bloque de instrucciones (líneas 9 a 11)
del else en línea 8. En línea 9 tenemos [Link](n), que es para agregar n a lista1 con
el método append. En línea 10 tenemos el equivalente a suma=suma+lista1[i], por lo que
con suma llevamos la suma de calificaciones. En línea 11 incrementamos el valor de i en
una unidad, por lo que en ese momento el valor de i es el número de calificaciones
introducidas en el rango correcto y además será la posición en lista1 de la siguiente
calificación. En línea 3 cuando la condición del while se evalúa False, que será cuando i=5,
finaliza el ciclo por lo que se tendrán 5 calificaciones en lista1 (con posiciones en el rango
de 0 a 4). Pasamos a la línea 13 que es para imprimir en pantalla el promedio de las
calificaciones, que es igual a la suma de las calificaciones capturadas (valor actual de suma)
entre el número de calificaciones (valor actual de i). Al correr el módulo, la salida depende
de las calificaciones que se introduzcan:

Introduce una calificación: 100

Introduce una calificación: 90
Introduce una calificación: 80
Introduce una calificación: 70
Introduce una calificación: 60
El promedio es: 80.0

Ejemplo 8

Es correcto tener un if dentro de un if, es decir, if anidados. Si tenemos dos modelos de

vehículos (Mustang y Camaro), pudiendo ser de transmisión automática o estándar, y de
determinado color, queremos saber su precio. El inventario es el siguiente: Mustang
automático en colores negro y blanco, cuyo precio es 150000, y Mustang estándar en azul,
que cuesta 100000. Camaro automático en rojo, gris, y café, cuyo precio es 160000, no hay
Camaro estándar. Desarrollar un programa que pregunte por modelo, transmisión y color,
para darnos el precio.

12
En este código hay que tener cuidado con la indentación que le corresponde al único while
(en línea 1), y a cada if, elif, y else. El while comprende el bloque de instrucciones de la
línea 2 a la 46. La condición del while es True, por lo que ejecutara su bloque de
instrucciones repetidamente hasta que la sentencia break en línea 46 lo termine. En líneas 2,
3, y 4 capturamos modelo, transmisión, y color, respectivamente. Notar que se usó el
método lower, que es para convertir la cadena capturada a minúsculas. La condición del if
en línea 6 es True si modelo hace referencia a 'mustang', la condición del elif en línea 23 es
True si modelo hace referencia a 'camaro', si se llega al else en línea 39 se tendría que
modelo no hace referencia a 'mustang' o a 'camaro'. Si en línea 6 la condición
modelo=='mustang' es True, se tendría que el automóvil es un mustang y se prosigue a
determinar el tipo de transmisión. Con el if en línea 8 evaluamos la condición
transmision=='automatico', con el elif en línea 15 la condición transmision=='estandar',
con el else en línea 20 se tiene que transmision es diferente que 'automatico' y que
'estandar'. Si transmision=='automatico' es True, tenemos un if, un elif, y un else (líneas 9,
11 y 13, respectivamente) para determinar si color es 'negro', si color es 'blanco', o si color
no es 'negro' ni 'blanco', respectivamente. Si transmision=='estandar' es True, tenemos un if

13
y un else (líneas 16 y 18, respectivamente) para determinar si color es 'azul', o diferente que
'azul', respectivamente.
Si modelo=='camaro' (línea 23) y transmision=='automatico' (línea 25) resultan True,
tenemos un if, dos elif, y un else para determinar el valor de color, si
transmision=='estandar' (línea 34) es True, imprimimos en pantalla que no hay camaro
estandar en existencia. Entonces con los valores de modelo, transmision, y color se llega a
una instrucción para imprimir un precio o bien notificar que no se tiene en existencia.
En la línea 42 se le pide al usuario escribir una cadena ('si' o 'no') que se asigna en
continuar. Si la condición del if en línea 43, es decir continuar=='si', es True se ejecuta la
sentencia pass (línea 44), que es una sentencia nula (no tiene efecto) por lo que el programa
continua y pasamos a la siguiente iteración del while. Tenemos un else en línea 45 para si
continuar=='si' es False, de ser así se ejecuta la sentencia break (línea 46) la cual finaliza el
while en línea 1. Al correr el programa, dependiendo de los valores que tomen modelo,
transmision, y color, se tendrá una salida:

mustang o camaro: camaro

automatico o estandar: automatico
Escoja color: gris
Un camaro automatico gris cuesta 160,000
Volver a intentar? si/no: si
mustang o camaro: mustang
automatico o estandar: estandar
Escoja color: verde
No tenemos mustang estandar verde
Volver a intentar? si/no: no

Sentencia For
Con la sentencia for se puede acceder a cada objeto de un iterable por medio de un bucle,
de uno a la vez. Un iterable ([Link]., una lista, tupla, conjunto, diccionario, o cadena) es un
objeto que contiene objetos y que los puede devolver (en orden) uno a la vez, por lo que se
puede iterar con un ciclo for. El número de iteraciones de un for es igual al número de
objetos del iterable, sin embargo, el curso normal de las iteraciones de un for se puede
interrumpir mediante la sentencia break. Si todas las iteraciones de un for se llevaron a
cabo, se ejecuta el bloque de instrucciones del else. La estructura es

for objeto in iterable:

bloque de código
else:
bloque de código

Con la sentencia for se puede ejecutar su bloque de código un número de veces que va de
valor inicial (incluyéndolo) a valor final (sin incluirlo). En la primera iteración índice =
valor inicial, en la siguiente iteración índice = índice + incremento, y así sucesivamente
14
hasta que índice >= valor final, en tal caso el ciclo for termina por lo que no se lleva a cabo
esa iteración. La estructura es

for (índice) in range (valor inicial, valor final, incremento):

bloque de código

Es posible omitir los valores valor inicial e incremento, por defecto valor inicial=0 e
incremento=1. La estructura es

for (índice) in range (valor final):

bloque de código

Se puede omitir solamente incremento. Entonces

for (índice) in range (valor inicial, valor final):

bloque de código

Nota: los valores valor inicial, valor final, e incremento deben ser números enteros, es decir
de clase int. Ejemplos

for i in range(8):
print(i)

Imprime en pantalla del 0 al 7 en incrementos de 1.

for i in range(1,5):
print(i)

Imprime en pantalla del 1 al 4 en incrementos de 1.

for i in range(0,10,2):
print(i)

Imprime en pantalla del 0 al 8 en incrementos de 2.

for i in range(0,-5,-1):
print(i)

Imprime en pantalla del 0 a -4 en incrementos de -1.

Ejemplo 9

Dada una lista de calificaciones convertir cada calificación a una letra correspondiente. De
modo que una calificación en el rango [90,100] equivale a una A, en el rango [80,90) es una
B, [70,80) es C, [60,70) es D, y [0,60) es NA.

15
La lista de calificaciones (lista1) es definida en línea 2. Resolveremos este ejemplo de dos
formas: procedimiento 1 (de la línea 5 a la 20) y procedimiento 2 (de la línea 23 a la 37).
Con Procedimiento 1 en línea 5 definimos una lista vacía (lista2), en esta agregaremos el
equivalente como letra de cada calificación en lista1. En línea 7 tenemos un for cuyo
bloque (líneas 8 a 18) se ejecutará una vez por cada calificación en lista1; de acuerdo con la
estructura del for cada calificación en lista1 será referenciada con elemento. En cada
iteración con un if (línea 9), tres elif (líneas 11, 13, y 15) y un else (línea 17) se determina a
que letra corresponde elemento. En la primer iteración elemento=77, la condición (77<80
and 77>=70) se evalúa True (línea 13) por lo que se ejecuta la línea 14, que es para agregar
una 'C' a lista2 con el método append. En la siguiente iteración elemento=80, la condición
(80<90 and 80>=80) da True (línea 11) por lo que se ejecuta la línea 12, que es para
agregar una 'B' a lista2. Y así sucesivamente con cada número en lista1. Al finalizar el for
de la línea 7 pasamos a la línea 20, que es para imprimir en pantalla lista2.

16
Con Procedimiento 2 en línea 23 definimos lista_letras, que es una lista con las letras a las
que es posible convertir una calificación. En línea 24 cambiamos el contenido de lista2 por
una lista vacía (ya que es donde agregaremos las calificaciones convertidas a letra) y
definimos n2=10, que usaremos para ir modificando el rango en el que puede estar una
calificación. El bloque del for en línea 26 va de la línea 27 a la 35, este for hace una
iteración por cada calificación (referenciada con elemento) en lista1. En línea 28 definimos
n1=100, ya que a partir de este número iremos definiendo el rango en el cual puede estar
una calificación. El bloque del for en línea 29 va de la línea 30 a la 35, en este for i va de
valor inicial=0 a valor final=len(lista_letras)=5 con incremento=1, por lo que ejecutará su
bloque de código tantas veces como el número de letras al que puede convertirse una
calificación, o bien puede ser terminado antes con la sentencia break en línea 33. En línea
31 tenemos un if con condición:

( elemento==100 or (elemento<n1 and elemento>=n1-n2) or i==4 )

Que en la primera iteración equivale a:

( elemento==100 or (elemento<100 and elemento>=90) or i==4 )

Si la condición es False pasamos a la línea 35, en donde al valor actual de n1 le restamos

n2=10 y el resultado es asignado nuevamente en n1, luego pasamos a la siguiente iteración
por lo que la condición del if cambia a:

( elemento==100 or (elemento<90 and elemento>=80) or i==4 )

y así sucesivamente hasta que la condición de True, de ser así se ejecutan las líneas 32 y 33;
en línea 32 tenemos [Link](lista_letras[i]), el valor de i es la posición en lista_letras
de la letra que corresponde con la calificación en elemento; en línea 33 tenemos la
sentencia break, que es para terminar el for en línea 29. Entonces se escoge la letra de
acuerdo con el valor de i, p. ej., si elemento está en el rango [90,100] entonces podría ser
que en línea 31 elemento==100 de True, o bien que (elemento<100 and elemento>=90) de
True, tenemos que i=0 y en lista2 agregamos lista_letras[0]='A'. Si elemento está en el
rango [80,90) entonces (elemento<90 and elemento>=80) da True, se tendría que i=1 y en
lista2 agregamos lista_letras[1]='B'. Para los rangos [70,80) y [60,70) se tendría que i=2 y
que i=3, respectivamente, que de acuerdo con lista_letras[i] son los índices que
corresponden a las letras 'C' y 'D', respectivamente. Cuando i==4 se tiene que elemento no
está en el rango [60,100], por lo que en lista2 agregamos lista_letras[4]= 'NA'. Para
cualquiera de los casos anteriores después de agregar la letra correspondiente a lista2 (en
línea 32), con la sentencia break en línea 33 terminamos el bucle for en línea 29 para
proseguir con la siguiente interacción del for en línea 26. Cuando el for en línea 26 haya
hecho una iteración por cada calificación en lista1, en lista2 tendremos la letra
correspondiente a cada calificación en lista1, luego pasamos a la línea 37 para imprimir en
pantalla lista2.

17
Notar que en procedimiento 2 con el for en línea 29 y el if en línea 31 se logra lo mismo
que en procedimiento 1 con el if, los tres elif y el else, en líneas 9, 11, 13, 15 y 17,
respectivamente. Al ejecutar el módulo la salida es:

['C', 'B', 'A', 'D', 'NA']

['C', 'B', 'A', 'D', 'NA']

Ejemplo 10

Obtener los números primos en el rango [2,12).

El for en línea 1 es para fijar el rango en el que buscaremos por números primos, el número
en cuestión es referenciado con n. El for en línea 2 es para que x vaya tomando un valor en
el rango [2, n); ya que los números primos solo tienen división exacta entre sí mismos y la
unidad, calcularemos el residuo de dividir n entre cada número en el rango [2,n), que son
los valores que puede tomar x. El if de la línea 3 tiene como condición n % x =¿ 0, si esta
condición da True para un valor de entre los que puede tomar x, n no es primo. Esto se debe
a que, si el residuo de dividir n entre x es cero, la división es exacta (el cociente es un
número entero que multiplicado por el divisor es igual al dividendo). Si se determinó que el
valor actual de n no es primo, se termina el for en línea 2 con el break en línea 5. Cuando
un for es finalizado sin que se deba a la sentencia break, se puede ejecutar el bloque de
instrucciones de un else; cuando el for en línea 2 finaliza sin que se deba al break en línea
5, es decir, cuando no hubo un valor de x para que la condición en línea 3 de True (o bien
cuando n=2), pasamos al else en línea 6 para ejecutar su bloque de instrucciones, la línea 7,
para imprimir en pantalla que n es primo. Al correr el módulo la salida es:

2 es número primo
3 es número primo
4 no es número primo
5 es número primo
6 no es número primo
7 es número primo
8 no es número primo
9 no es número primo
10 no es número primo
11 es número primo

18
Ejemplo 11

Encontrar los números pares e impares en el rango [1,11).

Con el for en línea 1 hacemos que n vaya tomando un valor en el rango [1,11). La
condición del if en línea 2 es n % 2=¿ 0, si es True n es par porque tuvo división exacta
entre 2 (el residuo es 0), si es False n no es par; si la condición es True se ejecuta el bloque
de instrucciones que comprende las líneas 3 y 4. Línea 3 es para imprimir en pantalla que n
es par. En línea 4 tenemos la sentencia continue que se usa para interrumpir la iteración
actual de un for y pasar a la siguiente iteración, por lo que en este caso impide que se
ejecute la línea 5. Tenemos que si n es par es necesario evitar la línea 5 que es para
imprimir en pantalla que n es impar, y por esta razón se usó la sentencia continue en línea
4. Cuando la condición en línea 2 es False, n es impar y pasamos a la línea 5. La salida es:

1 es impar
2 es par
3 es impar
4 es par
5 es impar
6 es par
7 es impar
8 es par
9 es impar
10 es par

Ejemplo 12

Crear una lista que contenga los números enteros en el rango [1,10). Calcular el promedio
de los números guardados en dicha lista.

19
En línea 1 definimos lista1 como una lista vacía. El bloque de instrucciones (la línea 3) del
for en línea 2 es para ir agregando en lista1 el valor actual de n, que va cambiando de valor
(en orden) en el rango [1,10). Para llevar la sumatoria en línea 5 definimos sumatoria = 0.
En cada iteración del for en línea 6 e hará referencia (en orden) a un valor de lista1, en línea
7 (que es el bloque de instrucciones del for en línea 6) el valor en turno e se suma con
sumatoria y el resultado a su vez se asigna en sumatoria, entonces la línea 7 equivale a
sumatoria = sumatoria + e, por lo que con sumatoria llevaremos la suma. Al finalizar el
for en línea 6 pasamos a la línea 9 para imprimir en pantalla el promedio, que es
sumatoria/len(lista1). Con len(lista1) obtenemos el número de valores en lista1. Al correr
el módulo la salida es:

Promedio = 5.0

Notar que se puede hacer la siguiente simplificación:

Y más aún:

Ya que sum(lista1) devuelve la suma de los valores en lista1. Entonces, la función

sum(lista) la podemos usar para obtener la suma de los valores a los que hace referencia
lista.

Ejemplo 13

Definir una lista que contenga tres listas de acuerdo con los siguientes valores:
20
A = [ [1, 0, 1], [1, 1, 1], [0, 1, 0] ]

Obtener una lista a partir de A, de modo que los 0 sean remplazados por 1, y los 1 por 0.

En línea 1 importamos el módulo copy. Con la instruccion [Link](A) creamos una

copia (profunda) de A y la asignamos en B. Para acceder a los valores de cada lista en A lo
hacemos con dos for (en líneas 7 y 9, respectivamente). Con el for en línea 7 haremos una
iteración por cada lista en A, el índice de las listas se lleva con i. Con el for en línea 9
haremos una iteración por cada valor de la lista en turno de A, el índice de los valores se
lleva con j. De acuerdo con los for en líneas 7 y 9, los valores [i][j] serán: [0][0], [0][1], [0]
[2], [1][0], [1][1], [1][2], [2][0], [2][1], [2][2]. Tenemos dos if para la toma de decisiones
de acuerdo con el valor en turno de A[i][j]. Con el if en línea 10 si A[i][j] hace referencia a
un 1, a B[i][j] le asignamos un 0 (ver línea 11). Con el if en línea 12 si A[i][j] hace
referencia a un 0, a B[i][j] le asignamos un 1 (ver línea 13). Al correr el módulo la salida
es:

A = [[1, 0, 1], [1, 1, 1], [0, 1, 0]]

B = [[0, 1, 0], [0, 0, 0], [1, 0, 1]]

Ejemplo 14

Dada una lista con números (lista1), determinar el número de veces que se repite cada
número.

21
El for en línea 5 (con bloque de instrucciones de la línea 6 a la 11) hace iteraciones igual al
número de valores en lista1, en cada iteración e hace referencia al valor en turno de lista1.
En lista2 iremos agregando los números que no se han repetido, por lo que si e no se
encuentra en lista2 (ver línea 6), se ejecutan las instrucciones (líneas 10 y 11) del bloque
del else en línea 9. La línea 10 es para agregar e en lista2 (que es la lista donde guardamos
un número cuando aparece por primera vez) y la línea 11 para agregar un 1 en lista3 (en
esta lista llevaremos la cuenta de las veces que se repite determinado número), por lo que
los valores e y 1, agregados a lista2 y lista3, respectivamente, comparten la misma
posición. Si e está en lista2, se ejecuta el bloque (líneas 7 y 8) del if en línea 6. La línea 7 es
para determinar la posición de e en lista2, esto se logra con i=[Link](e), por lo que i
hace referencia a un índice. En línea 8 contamos una repetición de e con lista3[i]+=1,
entonces la cuenta de las veces que el valor al que hace referencia e se ha repetido está en
lista3 en la posición i. Al correr el módulo la salida es:

lista2 = [80, 90, 70, 100]

lista3 = [4, 2, 3, 1]

El 80 se repite cuatro veces, el 90 dos veces, el 70 tres veces, y el 100 una vez. Otra forma
de imprimir en pantalla el resultado es:

for i in range(len(lista2)):
print(f'El {lista2[i]} se repite {lista3[i]}')

En pantalla veríamos:

El 80 se repite 4
El 90 se repite 2
El 70 se repite 3
El 100 se repite 1

22
Tarea

Tarea 1

Se tiene una lista de números que son las matrículas de las personas que asistieron a un
seminario. El usuario del programa desea conocer si determinada matricula está en la lista
de los asistentes. Desarrollar el código de manera que, si se introduce una matrícula no
valida, la pida de nuevo. Una matrícula valida es un numero entero. Al conocer si una
matrícula está o no en la lista de asistencia, preguntar si se desea continuar o si se desea
salir del programa. Ejemplo, si la lista de los asistentes fuera [12, 5, 33, 48, 21, 72], al
correr el programa la salida sería:

Introduzca una matrícula: 5

La persona con matrícula 5 si asistió
Desea continuar (si/no): si
Introduzca una matrícula: 6
La persona con matrícula 6 no asistió
Desea continuar (si/no): no

Tarea 2

Hacer un programa que, dada una lista con nombres de países, determine la cantidad de
nombres en la lista y el número de letras de cada nombre. Instrucciones adicionales: no usar
la función len(). Ejemplo, si la lista con nombres de países fuera
['Canadá','Alemania','México','India','Egipto','Vietnam'], al correr el programa la salida
sería:

Canadá = 6 letras
Alemania = 8 letras
México = 6 letras
India = 5 letras
Egipto = 6 letras
Vietnam = 7 letras

El número de nombres de países es 6

Tarea 3

Convertir una cadena de modo que el ultimo carácter pase a ocupar la primera posición, el
penúltimo pase a ocupar la segunda posición, y así para todos los caracteres. Es decir,
invertir la cadena introducida por el usuario. Instrucciones adicionales: no usar una función
que invierta la cadena. Ejemplo de correr el programa:

Introduce una palabra o un número, o q para salir: hola

hola invertido es aloh

23
Introduce una palabra o un número, o q para salir: 123
123 invertido es 321
Introduce una palabra o un número, o q para salir: q

Tarea 4

Dado un entero positivo a y un entero positivo b, de modo que b>a, calcular la sumatoria
de todos los números enteros en el rango [a,b]. Ejemplo de correr el programa:

Introduce el valor de a: 1
Introduce el valor de b: 100

La sumatoria es: 5050

Referencias

[1] stackoverflow. "int('123') in python - is it a function call or constructor call of 'int' class?"
[Link]
constructor-call-of-int-class (accessed.

24