GUIA PRACTICA DE LABORATORIO - Programación Anthony Angulo

Prácticas de Experimentación de Programación
Guías prácticas para estudiantes
Claustro de Computación Aplicada

y Metodologías de la Computación
ii
Claustro de Computación Aplicada y Metodologías de la Computación
Joe Frand Llerena Izquierdo (Coordinador)

Orlando Barcia Ayala
Mónica Daniela Gomez Ríos
Mónica María Miranda Ramos
Shirley Guisella Coque Villegas
Vanessa Alexandra Jurado Vite
Jessenia Guadalupe Chalen Ortega
Freddy Gabriel Buendia Gallegos
Ricardo Alfredo Naranjo Sánchez
Máximo Giovani Tandazo Espinoza
Nelson Salomon Mora Saltos
Daniel Humberto Plua Moran
Guillermo Omar Pizarro Vásquez
Galo Enrique Valverde Landívar
Lenin Estuardo Cevallos Robalino
Jose Roberto Jaime Carriel
Universidad Politécnica Salesiana

Sede Guayaquil
© 2021
iii
iv
Bienvenida
Estas guías de laboratorio son el resultado de la preocupación y

dedicación de un conjunto de profesores que con actitudes
propositivas comparten sus conocimientos en la asignatura de
Programación, y que se reflejan en este texto. Es uno de los medios
para validar los aprendizajes en el aula. ¡Es para ti!, para que, junto
a tus compañeros de aula, puedan resolverlos en tiempos
adecuados, de forma individual o grupal, y que te permitan
descubrir, mejorar y potenciar aquellos conocimientos, destrezas y
habilidades que te exigirán estas guías.
Esperamos que estas Guías de Prácticas, te animen a desarrollar

habilidades creativas, maximizar tus conocimientos, aumentar el
interés por investigar, a resolver los ejercicios de diferentes formas
y que genere en ti, una oportunidad de colaborar con los demás
compañeros enseñándoles de forma honesta.
Cordialmente,
Profesores del Claustro de Computación Aplicada y

Metodologías de la Computación
v
vi
ÍNDICE
Contenido
Claustro de Computación Aplicada y Metodologías de la Computación ............................................. iii
Bienvenida ............................................................................................................................................ v
Contenido ........................................................................................................................................... vii
Datos Informativos de la Asignatura..................................................................................................... 1

Unidad 3 - Desarrollo de Guías de Prácticas de Laboratorio ................................................................ 7
Práctica de Laboratorio 7.................................................................................................................. 7
Lenguajes de Programación .................................................................................................................. 9
Práctica de Laboratorio 8................................................................................................................22
Lenguajes de Programación ................................................................................................................24

Práctica de Laboratorio 9................................................................................................................32
Práctica de Laboratorio 10..............................................................................................................39

Finalización de este proceso ...............................................................................................................55
vii
viii
Datos Informativos de la Asignatura
PROGRAMA ANALÍTICO DE LA ASIGNATURA
[1] Datos informativos
Carrera: Ingenierías
Asignatura: Programación Nivel: 1
Código de la Asignatura: C-CT-ICO-101 Unidad de Organización Curricular:
Número total de horas: 160 UNIDAD BÁSICA
N° Horas Componente Docencia: 64 Campo de Formación:
N° Horas Componente Prácticas 32 FUNDAMENTOS TEÓRICOS
de Aplicación y Experimentación
de Aprendizajes:
N° Horas Componente de Trabajo 64 Modalidad: PRESENCIAL
Autónomo:
[2] Caracterización de la Asignatura
Dentro de la ingeniería, es necesario el análisis, diseño e implementación de una solución a un

problema planteado de forma algorítmica. La asignatura de programación permite la integración de
técnicas de solución de problemas, el uso de algoritmos computacionales y los conocimientos de
lenguajes de programación.
[3] Resultados de Aprendizaje

• Diseña soluciones a problemas de lógica empleando álgebra de Boole y teoría de
proposiciones.
• Diseña algoritmos para la resolución de problemas.
• Desarrolla aplicaciones utilizando el lenguaje de programación.
[4] Contenidos
Unidades Contenidos de la Unidad Resultados de Indicadores de Logro Total de

Temáticas Aprendizaje de la horas
Asignatura por
correspondientes a cada unidad
UNIDAD 1 Álgebra de Boole Diseña soluciones a Aplica lógica matemática
Lógica Teoría de proposiciones problemas de lógica para resolver problemas.
Matemática empleando álgebra de 30
Boole y teoría de
proposiciones.
UNIDAD 2 Formas de representar Diseña algoritmos para la Utiliza estructuras de
Algoritmos algoritmos resolución de problemas. control para resolver
Estructuras de Control problemas a través de 50
(Decisión, Repetitivas) algoritmos.
UNIDAD 3 Fundamentos Desarrolla aplicaciones Identifica la sintaxis y

Lenguaje de (generalidades, tipos de utilizando el lenguaje de semántica en un lenguaje
Programación datos, operadores, programación. de programación.
expresiones, variables) Diseña e implementa 80
Funciones programas en un lenguaje
Vectores, Matrices de programación.
Página 1 de 63
[5] Metodologías de aprendizaje
El Aprendizaje colaborativo, es la estrategia para incentivar el diálogo y discusión entre los estudiantes
y con el docente, donde todos los miembros colaboran en la construcción del conocimiento y
contribuyen al aprendizaje de todos.
Aprendizaje basado en problemas, mediante esta metodología, los estudiantes deben encontrar una
solución a un problema planteado, de este modo consiguen elaborar un diagnóstico de las necesidades
de aprendizaje, construir el conocimiento y trabajar cooperativamente.
Metodología “aula invertida”, es una metodología de aprendizaje semipresencial, donde los

estudiantes aprenden los conceptos desde casa viendo videos en línea y los ejercicios que
anteriormente fueron realizados en clase.
El Aprendizaje basado en investigación, considera al estudiante como protagonista de su propio

aprendizaje. Los estudiantes actúan como investigadores, aprenden y desarrollan habilidades
investigativas mediante la experimentación. La enseñanza se orienta a ayudar a los estudiantes a
comprender los fenómenos de la forma en que lo hacen los expertos.
Aprendizaje basado en proyectos.
Prácticas de laboratorio: propende a que los estudiantes adquieran las habilidades propias de los
métodos de la investigación científica, amplíen, profundicen, consoliden, realicen y comprueben los
fundamentos de la asignatura mediante experimentación.
[6] Procedimiento de Evaluación
Según el Reglamento Interno de Régimen Académico:
Artículo 41.- Evaluación de aprendizajes. - Para la aprobación de asignaturas en los niveles de grado,
independientemente de la modalidad de estudios, el estudiante debe demostrar dominio de
conocimientos, capacidades, destrezas y desempeños previstos en los resultados de aprendizaje. La
evaluación se realiza en forma sistemática y continua sobre un total de cien puntos divididos en dos
partes de cincuenta puntos cada una, que incluyen aprovechamiento y examen. La nota mínima para
la aprobación es de setenta puntos.
Artículo 42.- El aprovechamiento será evaluado y calificado con un mínimo de treinta puntos,
considerando los resultados de aprendizaje previstos en la planificación micro curricular y las
actividades de aprendizaje desarrolladas. La calificación de aprovechamiento será el resultado de por
lo menos tres actividades de aprendizaje, sean éstas de carácter colaborativo, prácticas de aplicación
y experimentación, trabajo autónomo, u otras:
De carácter colaborativo:
a. Sistematización de prácticas de investigación-intervención,
b. Proyectos de integración de saberes,
c. Construcción de modelos y prototipos,
d. Proyectos de problematización,
e. Resolución de problemas o casos.
Página 2 de 63
De prácticas de aplicación y experimentación:
a. Prácticas de campo,
b. Trabajos de observación dirigida,
c. Resolución de problemas,
d. Talleres.
De trabajo autónomo:
a. Elaboración individual de ensayos,
b. Trabajos y exposiciones,
c. Pruebas orales o escritas,
d. Resolución de guías didácticas,
e. Indagación bibliográfica.
Otras.
[7] Bibliografía
TEXTOS AUTOR; TÍTULO; EDICIÓN Y AÑO

BÁSICOS
1 L. Joyanes Aguilar; Fundamentos de programación Algoritmos y Estructuras de
Datos y Objetos; México: McGraw-Hill; 2013
2 Thomas H. Cormen; Introduction to Algorithms; Third edition; MIT Press; 2009
3 Steven S. Skiena; The algorithm Design Manual; Second edition; Springer; USA,
2008
4 Kent D. Lee; Foundations of Programming Languages; Springer; 2014
5 Arvind Kumar Bansal; Introduction to Programming Languages; CRC Press, 2014
6 Holly Moore; Matlab para Ingenieros; Pearson - Prentice Hall; 2007
LECTURAS
SUGERIDAS
1 Rod Stephens, Essential Algoritms (A Practical Approach to Computer
Algorithms), Wiley, 2013
2 Mauricio Ortiz, Andrea Plaza, Fundamentos de Programación en JAVA y UML,
UPS, Cuenca, 2013
3 Llerena Izquierdo, Joe, Codifica en Python, 2020
Sugerencias antes de iniciar su trabajo académico:
Compartimos algunas recomendaciones que pueden ayudarte desde la experiencia

docente.
a) Revise el material con anticipación para poder ampliar el tema a ser tratado.
b) Realice detenidamente la lectura de la sección en su conjunto para conocer el
alcance del tema y distribuir los tiempos.
c) Lea de forma reflexiva y sin prisa, el contenido de los ejercicios resueltos de
manera que pueda escoger otra alternativa de solución.
d) Lea nuevamente la Guía Práctica y centre su atención en los indicadores a
desarrollar en los participantes.
e) Recuerde que el trabajo realizado por usted debe ser de calidad para los
participantes.
Página 3 de 63
Página 4 de 63
# Unidad 3
% Unidad 3
Página 5 de 63
Página 6 de 63
Unidad 3 - Desarrollo de Guías de Prácticas de Laboratorio
“Esperamos que de esta guía logres los indicadores de resultado esperados”.
Práctica de Laboratorio 7
Guía Práctica de Laboratorio
Carrera: Ingenierías Asignatura: Programación

Nro. Práctica 7 Título Práctica 7: Lenguaje de Programación sección 1
OBJETIVO
Objetivo General:
Presentar soluciones algorítmicas a problemas reales mediante su representación en un
lenguaje de programación.
Objetivos Específicos:
• Identificar la sintaxis y semántica en un lenguaje de programación.
• Diseñar e implementar programas en un lenguaje de programación.
INSTRUCCIONES 1. Revisar material de profundización del tema.
2. Ampliar los conocimientos a través de los recursos
complementarios en la plataforma de los ambientes
virtuales contrastando con los ejercicios propuestos.
3. Desarrollar cada sección propuesta en este documento,
utilizando el formato para el estudiante.
4. Fecha de entrega en acuerdo con el docente. Es importante
que su solución refleje todo el proceso que se debe seguir
para obtener la respuesta (especifique adecuadamente la
realización de su trabajo y bien argumentado).
5. El puntaje final de la práctica guarda correspondencia con
contenido en el sílabo de la asignatura (indicador de logro)
Valor: ____ puntos.
6. El indicador de logro a alcanzar es: Identifica la sintaxis y
semántica en un lenguaje de programación.
ACTIVIDADES POR DESARROLLAR
1. Realizar las actividades planteadas en este documento
2. Presentar la solución sobre este formato y bien expresado el proceso
utilizado.
RESULTADO(S) OBTENIDO(S)
Desarrolla aplicaciones utilizando el lenguaje de programación.
CONCLUSIONES
Los practicantes mejoran el conocimiento aprendido en base a la experimentación
realizada, desarrollando algoritmos y representándolos en programas de aplicación.
RECOMENDACIONES
Despejar las dudas que puedan surgir al momento de realizar la práctica.
Revisar detalladamente la información entregada por el claustro.
Docente:
Firma:
Página 7 de 63
Rúbrica de evaluación
RÚBRICA DE EVALUACIÓN DE LA PRÁCTICA 7

Nombre de estudiante:
Fecha:
Por
Muy
DESCRIPCIÓN DEL Excelente Bueno Regular mejorar
CRITERIO bueno
CRITERIO 80% 60% 40% menos
70%
de 40%
Experiencia concreta
Responsabilidad Académica
[Sentir] – Actuar
Reflexión
[Analizar] - Observar
Las actividades académicas las he realizado con:

Honestidad académica: sin
Responsabilidad
10% 20% 20% 20% 20%

plagio o copia
Formativa
Dedicación responsable 5% 5% 5% 5% 5%
Puntualidad en la entrega 5% 5% 5% 5% 5%
TOTAL sobre 100% del puntaje asignado
Observaciones y retroalimentación
Firma y nombre de:
Estudiante Profesor
Página 8 de 63
LENGUAJES DE PROGRAMACIÓN
A continuación, debes revisar los siguientes enlaces para empezar las guías de esta
unidad.
Fase 1:
En esta sección revise los siguientes sitios web:
(http://www.mclibre.org/consultar/python/lecciones/python-funciones-1.html |
http://www.mclibre.org/consultar/python/lecciones/python-funciones-2.html ).
1. Sitio 1
2. Sitio 2
Luego, siga los ejercicios de las imágenes con interacción (tienen esta forma):
Referencia: http://www.mclibre.org/consultar/python/index.html
Fase 2:
A continuación, complete el código faltante, hágalos funcionar entendiendo lo realizan
cada uno de ellos y agregando el código de contexto requerido para se ejecute sin error,
(agregue e importe librerías necesarias y en la plataforma de desarrollo que usted
prefiera), recuerde que debe llegar a la ejecución final correcta del mismo.
def rellenar_matriz(filas, columnas, matriz):

for f in range(filas):
matriz.append([])
for c in range(columnas):
matriz[f].append(int(input("digite el número de la posición fila: ",(f+1),"columna: ",
(c+1))))
print (matriz)
def sumar_matriz (matriz, filasu, columnas, filas):

sumafila=0
for x in range (filas):
sumafila =sumafila+ matriz [filasu][x]
print("la suma es: " , sumafila)
Página 9 de 63
opciones =["1", "2", "3", "4", "5", "6"]
while True:
print('''
Selecione una opcion(1, 2, 3, 4, 5, 6):
1. Rellenar matriz
2. Suma Fila
3. Suma columna
4. Suma Diagonal principal
5. Suma Diagonal Inversa
6. Salir
''')
opcion=input("Introduce una Opción: ")

if not (opcion in opciones):
print("No selecciono ninguna opcion valida")
input ("Pulse para continuar")
continue
if (opcion =="1"):
try:
filas=int(input("ingrese la cantidad de filas"))
columnas=int(input("ingrese la cantidad de columnas"))
matriz=[]
rellenar_matriz(filas, columnas, matriz)
rellenado= True
except:
input = ("Pulse para ir al menú")
continue
if (opcion =="2"):
try:
if rellenado:
filasu=int(input("Digite la fila a Sumar"))
if (filasu >= 0 and filasu <=filas):
sumar_matriz(matriz, filasu, columnas, filas)
print("Ya se lleno la matriz")
else:
print ("Digite una Fila en el valor correcto")
except:
print("aún no se rellena")
….. ahora siga usted completando el código necesario. Referencia:

https://unipython.com/php-arrays-o-matrices-simples/
Fase 3:
Revise los siguientes videos de los temas del capítulo:
Matrices Arreglos Métodos Punteros
enlace enlace enlace enlace

http://bit.ly/2GrjauZ http://bit.ly/2GnxLq8 http://bit.ly/2vfxwYZ http://bit.ly/2GsfGIH
Página 10 de 63
Efectuar la solución del problema usando el lenguaje Python y utilice como variables sus
nombres y apellidos, ejemplo si usted se llama Juan Antonio Ramos Morales, use esa
información en las variables como “area”, “perimetro” o “suma” por “Juan”, “Antonio”
o “Ramos”. ADEMÁS, A CADA EJERCICIO, DENTRO DEL CÓDIGO DEBE
INCLUIR SU NOMBRE Y APELLIDO COMO COMENTARIO. EN EL
DOCUMENTO DE WORD COLOCA EL CÓDIGO Y ADJUNTA LOS ARCHIVOS
DESARROLLADOS EN PYTHON DE EXTENSIÓN *.py
Se pueden resolver con listas bidimensionales algunos de los siguientes problemas:

1. Lea una matriz cuadrada. Descomponga la matriz en tres matrices: submatriz debajo
de la diagonal, submatriz diagonal, y submatriz sobre la diagonal. Verifique que la
suma de las tres matrices coincide con la matriz original. Muestre las matrices
obtenidas.
import numpy as np
import random as ra
matriz = np.zeros((4,4))
A = np.zeros((4,4))
B = np.zeros((4,4))
C = np.zeros((4,4))
for i in range (len(matriz)):

for j in range(len(matriz[i])):
matriz[i][j] = ra.randint(1,10)
if (i == j):
A[i][j] = matriz[i][j]
if (i < j ):
B[i][j] = matriz[i][j]
if (i > j):
C[i][j] = matriz[i][j]

print('\t', matriz[i][j], end=' ')
print()
print()
print('\t', A[i][j], end=' ')
print()
print()
print('\t', B[i][j], end=' ')
print()
print()
print('\t', str(C[i][j]), end=' ')
print()
Página 11 de 63
2. Lea una matriz n x m. Para cada fila, muestre el producto de los elementos cuyo valor
es un número par.
import numpy as np
n = 4
m = 3
M = np.zeros((n, m))
for i in range(len(M)):
for j in range(len(M[i])):
M[i][j] = int(np.random.rand()*10)
print(M[i][j], end=' ')
print()
producto = 1
print()
if (M[i][j] % 2 == 0 and M[i][j] != 0):
producto = producto * M[i][j]
print("\t",M[i][j],end=' ')
if( producto != 1):
print("\t", producto)
producto = 1
print()
3. Lea una matriz cuadrada. Muestre la suma de los elementos que no están en las dos
diagonales principales.
import numpy as np
n = 4
m = 4
M = np.zeros((n, m))
M[i][j] = int(np.random.rand()*10)
print(M[i][j], end=' ')
print()
suma = 0
print()
print('\t',M[i][j], end=' ')
if not (i == j or j == len(M[i])-1-i ):
suma = suma + M[i][j]
print('\t = ',suma)
suma = 0
4. Un cuadrado semi-mágico es una matriz cuadrada conteniendo números tales que la

suma, de las dos diagonales principales producen el mismo resultado.
Ejemplo. Un cuadrado semi-mágico de 4 filas y 4 columnas:
Página 12 de 63
8 1 6 7
6 5 7 3
4 3 2 1
2 8 9 4
import numpy as np
t = 4
A =np.zeros((t,t))
contador = 0
while(True):
for i in range(len(A)):
for j in range(len(A[i])):
A[i][j] = int(np.random.rand() * 10)
D1 = 0
D2 = 0
for i in range(len(A)):
for j in range(len(A[i])):
if (i == j):
D1 = D1 + A[i][j]
if (j == len(A[i]) - 1 - i):
D2 = D2 + A[i][j]
print('\t', A[i][j], end=' ')
print()
print()
if (D1 == D2):
print(D1, " es igual a ", D2)
break
contador = contador + 1
print("Hubieron ",contador," repeticiones")
Escriba un programa que coloque números enteros aleatorios de una cifra en una
matriz de 4 filas y 4 columnas. Repita el ciclo hasta que la matriz sea un cuadrado
semi-mágico.
El programa debe mostrar la matriz resultante y la cantidad de intentos que realizó el
programa hasta llenar la matriz con éxito.
ar = [[8,1,6,7],[6,3,4,3],[4,2,3,1],[2.8,9,4]]
def print_spiral(ar):
contador = 1
acumulador = 0
acumulador1= 0
rows, cols = len(ar), len(ar[0])
R, C = 0, -1
nextturn = stepsx = cols
stepsy = rows -1
inc_c, inc_r = 1, 0
turns= 0
for i in range (rows * cols):
c+= inc_c
r+= inc_r
print (ar[r][c])
Página 13 de 63
if i ==nextturn -1:
turns+=1
if turns%2==0
nextturn+= stepsx
steps-=1
else:
nextturn+ = stepsy
stepsx-=1
inc_c, inc_r= - inc_r, inc_c
contador+= 1
acumulador+= inc_c
acumulador1= acumulador + inc_r
prom= 4.91
print= (prom)
5. Escriba un programa que coloque números aleatorios de una cifra en los cuatro bordes
de una matriz. Después rellene los elementos del interior de la matriz con números
aleatorios de una cifra, tales que cada uno sea menor o igual al promedio de todos los
elementos en los bordes.
Ejemplo. Matriz inicial de 4 x 4 Matriz rellena:

8 1 6 7 8 1 6 7
6 3 promedio: 4.91 6 3 4 3
4 1 4 2 3 1
2 8 9 4 2 8 9 4
Al inicio no interesan los valores que se asignan a los elementos interiores pues serán
sustituidos.
El programa debe mostrar la matriz resultante y la cantidad de intentos que realizó el
programa hasta llenar la matriz con éxito.
listatotal = [3,2,7,9]
lista1 = [6,5,3,7]
lista2 = [8,8,1,6]
lista3 = [3,5,9,2]
listatotal = (listatotal, lista1, lista2, lista3)
print(listatotal)
A1 = (listatotal)[::-1]
A2 = (lista1 )
A3 = (lista2)
A4 = (lista3)
print
Página 14 de 63
6. Escriba una función b=diagonales(a) que reciba una matriz nxn e intercambie los
elementos de la diagonal principal con los elementos de la otra diagonal.
Ejemplo: Matriz inicial de 4 x 4 Matriz modificada
3 2 7 9 9 2 7 3
6 5 3 7 6 3 5 7
8 8 1 6 8 1 8 6
3 5 9 2 2 5 9 3
En la ventana interactiva genere una matriz cuadrada con números aleatorios de
una cifra. Llame a la función y verifique si el resultado es correcto.
import numpy as np
t = 4
B = np.full((t,t),0)
for i in range(len(B)):
for j in range(len(B[i])):
B[i][j] = np.random.randint(10)
print(B)
print()
# código de la función
for i in range(len(B)):
for j in range(len(B[i])):
if(i == j):
guardar = B[i][j] # 3
B[i][j] = B[i][len(B) - 1 - i] # 3 por el 9
B[i][len(B) - 1 - i] = guardar # 9 por el 3
print(B)
def tema7(B):
lista = []
for j in range(len(B)):
par = 0
for i in range(len(B[j])):
if (B[i][j] % 2 == 0 and B[i][j] != 0):
par = par + 1
lista.append(par)
print(lista)
return
7. Escriba una función que reciba una matriz. La función debe entregar un vector con la
cantidad de elementos pares que contiene cada columna de la matriz:
3 4 5
Ejemplo. Entra [ 6 1 8 ] sale [2, 3, 1]
8 6 3
7 8 7
def tema8(B):
lista = []
for j in range(len(B)):
par = 0
Página 15 de 63
for i in range(len(B[j])):
if (B[i][j] % 2 == 0 and B[i][j] != 0):
par = par + 1
lista.append(par)
print(lista)
mayor = -999
for m in range (len(lista)):
if lista[m] >= mayor:
mayor = lista[m]
columna = m
print("La columna con mayor cantidad de pares es ", (columna+1))
return
8. Escriba un programa que lea una matriz, llame a la función creada y determine cuál
es la columna con la mayor cantidad de números pares.
#Carlos Paredes
import numpy as np
listinic= [3,4,5]
list1= [6,1,8]
list2= [8.3,2]
listot= listinic + list1 + list2
PARNUM1= []
PARNUM2= []
PARNUM3= []
CONTADOR1=[]
CONTADOR2=[]
CONTADOR3=[]
print(listot)
9. Escriba una función con nombre suma(n) que entregue la suma de las cifras de un
número dado n. Con esta función escriba un programa que genere 10 números
aleatorios entre 1 y 100 y encuentre cuál de ellos tiene la mayor suma de sus cifras.
X = 0
Y = 0
n = int(input("INGRESAR UN VALOR: "))
X = X + sum(n)
Y = Y + sum(n)
print(X, ' ', Y)
if (Y > X):
print("Si es mayor")
else:
print("Si es menor")
import random as aleatorio
def sum (n):
acum = 0
for i in range (1, 10):
a= aleatorio.randint(1,100)
acum= acum+ a
r = acum + n
return r
Página 16 de 63
10. Escriba una función llamado cuadrado(n) que determine si el cuadrado de un número
natural n dado, es igual a la suma de los primeros n números impares. Ej. 62 =
1+3+5+7+9+11 Escriba un programa de prueba que ingrese un dato desde el teclado,
use la función y muestre el resultado en la pantalla.
N = int(input("INGRESAR EL NUMERO: "))

A= elvalcuadrado(N)
print("EL EXPO AL CUADRADO ES ", A)
def elvalcuadrado (N):

acumulador= 0
contador= 1
R =N ** 2
while (R != acumulador):
if (contador % 2 == 1):
acumulador = acumulador + contador
print= (contador, end ='+')
contador = contador + 1
print("\n LA SUMA DE ELAVCUADRADO ES " , acumulador )
return R
11. Escriba una función secuencia1(n) que entregue el n-ésimo término de la siguiente
secuencia, en la cual cada término, a partir del tercero se obtiene sumando los dos
anteriores: 1, 1, 2, 3, 5, 8, 13, 21, .... Escriba un programa de prueba que ingrese un
dato desde el teclado use la función y muestre el resultado en la pantalla.
def secuenciade1 (N):

if(N==0):
return 0
if(N==1):
return 1
return(secuenciade1(N-1)+secuenciade1(N-2))
N= int(input("INGRESAR NUMERO"))
for i in range(0,N):
print(secuenciade1(i) ,end=' ')
12. Escriba una función secuencia2(n) que entregue el n-ésimo término de la siguiente
secuencia, en la cual cada término, a partir del cuarto se obtiene sumando los tres
anteriores: 1, 1, 1, 3, 5, 9, 17, 31, 57… Escriba un programa de prueba que ingrese un
dato desde el teclado, use la función y muestre el resultado en la pantalla.
def secuenciade1 (N):

if(N==0):
return 0
if(N==1):
Página 17 de 63
return 1
if (N == 2):
return 1
if (N == 3):
return 1
return(secuenciade1(N-1)+secuenciade1(N-2)+secuenciade1(N-3))
N= int(input("INGRESAR NUMERO"))
print(secuenciade1(i) ,end=' ')
13. Escriba una función simetrico(x) que reciba un entero y determine si es simétrico, es
decir si los dígitos opuestos alrededor del centro son iguales. Escriba un programa de
prueba que genere números aleatorios entre 1 y 10000 hasta obtener un número que
sea simétrico.
import random
def SIMETRICO(X):
M=X
CONT=0
al=random.randint(1,10000)
while(M>0):
if (M%10==0):
print("Esto no es simetrico")
else:
H=int(M/10)
F=M%10
if (H==F):
print("SI HAY SIMETRIA")
break
else:
print("NO HAY SIMETRIA")
break
CONT=CONT + 1
NUM=int(input("UN NUMERO: "))
print(SIMETRICO(NUM))
14. Escriba una función final(n) que entregue como resultado la cantidad de veces que
debe lanzarse un dado hasta que salga un número n dado como parámetro. Escriba un
programa de prueba que ingrese un dato desde el teclado, use la función y muestre el
resultado en la pantalla.
import random as aleatoria

def FINALIZADO(N):
DADO=aleatoria.randint(1,6)
return(DADO)
N=0
DADO1=FINALIZADO(N)
DADO2=FINALIZADO(N)
Página 18 de 63
DADO3=FINALIZADO(N)
print("DADO1:", DADO1, "DADO2:", DADO2, "DADO3:", DADO3)
15. Escriba una función conteo(x) que determine la cantidad de términos que deben
sumarse de la serie: 1*2*3 + 2*3*4 + 3*4*5 + 4*5*6+ hasta que la suma exceda a un
valor x dado. Escriba un programa de prueba que genere un número aleatorio para x
entre 1 y 1000, use la función y muestre el resultado en la pantalla.
import random
def terminado(n):
da=random.randint(1,6)
return (da)
X2 = int(input(" NUMEROS DEL 1 HASTA EL 6: "))
X1=0
D1= terminado(x1)
D2= terminado(x1)
D3= terminado(x1)
print(f"\n dig1 {D1}\n dig2{D2} \n dig33 {D3}")
if (X2 == da01 ):
print(f"{X2} es igual a dig1")
elif(X2 == da02):
elif (X2 == D3):
elif(X2> 6):
print(f"{X2} es mayor ")
elif(X2< 6):
print(f"{X2} es menor")
else:
16. Haz un programa que almacene en una variable a la lista obtenida con range(1,4) y, a
continuación, la modifique para que cada componente sea igual al cuadrado del
componente original. El programa mostrará la lista resultante por pantalla.
list =[1,2,3,4]
print(list)
for i in range(0,len(list)):
list[i]= list[i]*list[i]
print(f"EL CUADRADO ES {list}")
17. Haz un programa que almacene en a una lista obtenida con range(1, n), donde n es un
entero que se pide al usuario y modifique dicha lista para que cada componente sea
igual al cuadrado del componente original. El programa mostrará la lista resultante
por pantalla.
Página 19 de 63
NUMERO= int(input("CUALQUIER NUMERO:"))
lsit =[]
for i in range (1,NUMERO+1):
lsit.append(i)
print(lsit)
for j in range(1,len(lsit)):
lsit[j]= lsit[j]* lsit[j]
print(f"EL CUADRADO ES: {lsit}")
18. Haz un programa que, dada una lista a cualquiera, sustituya cualquier elemento
negativo por cero.
import random
nums= int(input("UN NUMERO :"))
list=[]
19. Diseña un programa que construya una lista con los n primeros números primos (ojo:
no los primos entre 1 y n, sino los n primeros números primos). ¿Necesitas usar
append? ¿Puedes reservar en primer lugar un vector con n celdas nulas y asignarle a
cada una de ellas uno de los números primos?
li=[]
N = int(input("Ingrese un número: "))
for H in range(1,N+1,1):
C = 0
for M in range(1,H+1,1):
if (H%M==0):
C = C + 1
if (C <= 2):
li.append(K)
print(li)
20. Diseña un programa que elimine de una lista todos los elementos de índice par y
muestre por pantalla el resultado. (Ejemplo: si trabaja con la lista [1, 2, 1, 5, 0, 3], ésta
pasará a ser [2, 5, 3].)
import random
A=[]
B=[]
N= int(input(" TAMAÑO DE LA LISTA ES:"))
X=int(input("NUMERO DE LA LISTA ES :"))
Y= int(input("HASTA QUE NUMERO DE LA LISTA ES: "))
Página 20 de 63
for i in range(N):
ra= B.append(random.randint(X,Y))
print(B)
(Para los ejercicios 16, 17, 18, 19 y 20 utilice la sección 5.2.3 el operador is del pdf de:
https://www.u-
cursos.cl/ingenieria/2011/2/CC3501/1/material_docente/bajar?id_material=381752)
Página 21 de 63

OBJETIVO
Objetivo General:
Valor: ___ puntos.
6. El indicador de logro a alcanzar es: Identifica la sintaxis y
semántica en un lenguaje de programación.
utilizado.
CONCLUSIONES
RECOMENDACIONES
Docente:
Firma:
Página 22 de 63

Fecha:
Por
Muy
CRITERIO bueno
70%
de 40%
[Sentir] – Actuar
Reflexión

Responsabilidad
10% 20% 20% 20% 20%

plagio o copia
Formativa
Firma y nombre de:
Estudiante Profesor
Página 23 de 63
1. Escriba un programa que muestre la siguiente figura:

\ | /
@ @
*
\"""/
print("\ | /")
print(" @ @")
print(" *")
print("\ \"\"\" /")
2. Siendo a="Hola", b="mundo", c=87 y d=2.33145, armar y mostrar las siguientes

cadenas:
"Hola mundo" (usando a y b)
"-Hola-mundo-" (usando a y b)
"El resultado es: 87" (usando c)
"El resultado es: 87min (5220seg)" (usando c ambas veces)
"La temperatura es: 2.3"
A= "HOLA"
B= "MUNDO"
C=87
D=2.3314
E= C * 60
print(' ' '
{0} {1}
-{0}-{1}-' ' ' .format(a, b))
print(' ' 'EL RESULTADO ES :{0}
EL RESULTADO ES{0} minutos ({2} segundos)
Página 24 de 63
La temperatura es: {1: if}
' ' ' format (c, d, e))
3. Hacer un programa que le pida una cadena al usuario (usando la función "input") y la
imprima a pantalla al revés. Por ejemplo, para el texto "Esto es así", debería mostrar:
"ísa se otsE"
palb= "Esto es asi"

for otra in range(len(palb), 0, -1):
print(palb[otra-1], end = '')
4. Hacer un programa que le pida un número al usuario (usando la función "input") y

muestre ese número menos dos, más dos, multiplicado por dos, dividido por dos,
dividido por dos de forma entera, y elevado a la potencia de dos. Por ejemplo, para el
número 7, debería mostrar:
5
9
14
3
3.5
49
A= "SIETE"
B=7
C=B-2
D=B+2
E=B*2
F=B/2
G=B**2
print(C)
print(D)
print(E)
print(F)
print(G)
5. Pedirle un número al usuario, elevarlo al cuadrado, y mostrar los dígitos al revés y

separados por espacio. Por ejemplo, si el usuario ingresa 17, la salida tiene que ser "9
8 2".
N= int(input("INGRESAR UN NUMERO"))
A= N** 2
print(A)
print(int(str(A)[::-1]))
Página 25 de 63
6. Pedirle tres números (que pueden ser con decimales) al usuario, base y altura de un
rectángulo, y radio de un círculo. Calcular perímetro y área de cada figura.
from math import pi

BASE=int(input("Ingrese base "))
H=int(input("Ingrese altura "))
RADIO=int(input("Ingrese radio "))
print(f'''
Perimetro y area del rectangulo
P = 2*({BASE} + {H})= {2*(BASE*H)}
A = {BASE} * {H}= {BASE * H}
Perimetro y area del círculo
P = 2 * pi * {RADIO} = {2 * pi * RADIO}
A = pi * {RADIO}^2 = {pi * RADIO**2}
''')
7. Pedirle un número con muchos decimales al usuario y mostrarlo redondeado a 3

dígitos decimales, y como entero. ¿Qué tipo de redondeo usó? ¿Por qué?
N =float(input("IMGRESAR UN NUMERO "))
print("{:3f}".format(N))
print(round(N))
8. Sumar 0.3 diez veces. Por otro lado, multiplicar 0.3 por diez. ¿El resultado es el
mismo? ¿Por qué? ¿Qué tipo de dato debe usar?.
A= 0.3
B= A*10
C=A**10
print(B,' ', C)
9. Pedirle una frase al usuario e imprima, en orden, qué consonantes se utilizaron. Por
ejemplo, si se ingresó "la rana rené", mostrar "lnr".
10. Mostrar los números potencia de 2 menores a 10000 de la siguiente manera:

0001
0002
0004
0008
...
Página 26 de 63
8192
11. Pedir una frase al usuario y mostrar en mayúscula la inicial de cada palabra. Ejemplo,
si el usuario ingresa "No somos nada", mostrar NSN.
FRA= input("INGRESE LA FRASEE:")

inits= "".join(X[0]for X in FRA.split())
print(inits.upper())
12. Hacer un programa que le pida una cadena al usuario, y arme una triángulo creciente
y decreciente con ese texto. Por ejemplo, para el texto "klop", el resultado sería:
k
kl
klo
klop
klo
kl
k
13. Escribir un programa que le pregunte un número al usuario. Si el número es 5, que

muestre ¡“Suerte!"; si el número es mayor a 10, que muestre "Grande!"; para los otros
casos que muestre "Sin suerte, :(".
MUE= input("EL NUMERO ES:")

NUMERO= int(MUE)
if NUMERO == 5:
print("¡SUERTE!")
elif NUMERO>10:
print("¡BUENA CRACK!")
else:
print("¡MALA SUERTE!")
14. Escribir un programa que le pregunte un número al usuario. Si el número es 5, que

muestre ¡“Suerte!"; si el número es mayor a 10, que le vuelva a pedir el número al
usuario; para los otros casos que muestre "Sin suerte, :(".
Página 27 de 63
15. Hacer una función que recibe un número y contesta "par" o "impar" en función de si
el número es par o no.
16. Hacer una función que recibe dos números y devuelve "mayor" (si el primer número
es mayor que el segundo), "menor", o "iguales".
def determinar(m1, m2):

if (m1 == m2):
print(m1,"es igual a",m2)
else:
if (m1 > m2):
print(m1,"es mayor a",m2)
else:
print(m1, "es menor a", m2)
return
nu1 = int(input("Ingrese un número: "))

nu2 = int(input("Ingrese otro número:"))
determinar(nu1,nu2)7
17. Hacer un programa que genere un número entero al azar (módulo random) entre 0 y
1000, y le vaya pidiendo al usuario que ingrese números enteros para adivinarlo. Si el
usuario ingresa un número menor que el objetivo, muestra ¡“Es más alto!"; si el
usuario ingresa uno mayor, muestra “Es más bajo!”; si el usuario acierta, muestra
“Viva Python!”, y termina. Si el usuario no acertó en 7 intentos, muestre ¡“Alpiste
perdiste! Booo” y termine.
import random
lim= 7
TAR= random.randint(0, 1000)
for i in range(1, lim+1):
NUMERO=input("el numerro es : ".format(i))
Página 28 de 63
NUMERO= int(NUMERO)
if NUMERO<TAR:
print("ES ALTO")
elif NUMERO>TAR:
print("ES BAJO")
else:
print("¡VIVAA PYTHON!")
break
else:
print("Apliste perdiste BOOO")
18. Hacer una función que reciba un texto y devuelva el mismo texto, pero con cada
palabra invertida. Por ejemplo, llamándola con “Esto es una prueba”, debe devolver
"otsE se anu abeurp".
def invr(textoo):
PLS= textoo.split()
invr= [X[::-1]for X in PLS]
txtinv= " ".join(invr)
return txtinv
assert invr("ESTO ES UNA PRUEBA")=="otsE se anu abeurp"
19. Hacer una función que reciba dos palabras y que imprima línea por línea las primeras,
segundas, etc. letras de ambas palabras. Por ejemplo, llamándola con "Hola" y
"mundo", el resultado sería:
H m
o u
l n
a d
o
def CLMN (PALBNUMERO1, PALBNUMERO2):

if len(PALBNUMERO1)!= len (PALBNUMERO2):
MSLAR= max(len(PALBNUMERO1),len (PALBNUMERO2))
PALBNUMERO1=PALBNUMERO1(MSLAR)
PALBNUMERO2=PALBNUMERO2(MSLAR)
for a, b in zip(PALBNUMERO1,PALBNUMERO2):
print(a,b)
CLMN("Hola", "Mundo")
20. Armar una función que reciba una tupla y devuelva si la tupla está ordenada (de menor
a mayor) o no.
Código de utilidad:
#Escriba un algoritmo que permita hallar la suma de los N primeros números enteros
Página 29 de 63
N = input("Ingresar el número: ")
suma = N
i = 0
print ("Suma")
for i in range(N):
suma = suma + i;
print ("La suma es:", suma)
#Escriba un algoritmo que permita hallar cualquier tabla de multiplicar

N = input("Ingresar el número de la tabla de multiplicar: ")
for i in range(1,13):
print (" %d * %d= %d" % (N,i,N*i))
#Escriba un algoritmo que permita hallar si e primo o no

a=0
n=int(input("Ingrese número\n"))
for i in range(1,n+1):
if(n % i==0):
a=a+1
if(a!=2):
print("No es primo")
else:
print("si es primo")
def ordenado (tpl):

odn= tpl(sorted(tpl))
return tpl==odn
assert ordenado((1,2,4))
assert not ordenado((1,4,2))
assert not ordenado((3,2,1))
21. Se tiene un arreglo de diez números, solicite al usuario un número a encontrar, el

programa debe buscar el valor e indicar si lo encontró o no lo encontró y finaliza
mostrando el número (si lo encontró) en la posición y ubicación en el arreglo (vector).
A= []
R=0
for i in range(1,10+1):
B= int(input("LOS VALORES SON"))
A.append(B)
if (A ==B):
print("Lo encontrastes")
else:
print("No lo encontrastes")
print(A)
Página 30 de 63
22. Realice la sumatoria de los números del 1 al 10, visualizando los números de dos
formas, ascendente y descendentemente (de forma horizontal), al final de la línea de
números muestre a suma total.
A= [1,2,3,4,5,6,7,8,9,10]
SUMA= sum(A[0:len(A)])
print(A, '=,',SUMA)
Página 31 de 63

OBJETIVO
Objetivo General:
Valor: ___ puntos.
6. El indicador de logro a alcanzar es: Diseña e implementa
programas en un lenguaje de programación.
utilizado.
CONCLUSIONES
RECOMENDACIONES
Docente:
Firma:
Página 32 de 63

Fecha:
Por
Muy
CRITERIO bueno
70%
de 40%
[Sentir] – Actuar
Reflexión

Responsabilidad
10% 20% 20% 20% 20%

plagio o copia
Formativa
Firma y nombre de:
Estudiante Profesor
Página 33 de 63
1. Elabore un programa que muestre los números del 1 al 10 de forma ascendente.
def seriede1(fin):
for i in range(1,fin+1,1):
print(i, end=' ')
return
m = int(input("Ingrese un número: "))

seriede1(m)
2. Elabore un programa que muestre los números del 1 al 10 de forma descendente
def serie2(fin):
i = fin
while (i > 0):
print(i, end=' ')
i = i - 1
return

serie2(m)
def seriede2(fin):
for i in range(fin,0,-1):
print(i, end=' ')
return
3. Desarrolle un programa que dado un número determine la sumatoria del 1 hasta ese
número
Página 34 de 63
def sumatoria(x):
sum = 0
for i in range(1, x + 1, 1):
sum = sum + i
print(sum)
return
h = int(input("Ingrese un número: "))

sumatoria(h)
4. Determine la secuencia de Ulam para un número n determinado o ingresado por

teclado.
N=int(input("LOS NUMEROS SON"))

while(N>1):
if (N%2==0):
N=N//2
else:
N=N*3+1
print(N, end='')
5. Determine la secuencia de Fibonacci para un número n determinado o ingresado por

teclado.
def fibonacci(N):
if(N==0):
return 0
if(N==0):
return 1
return(fibonacci(N-1)+(N-1))
N=int(input("LOS NUMEROS SON"))
for i in range(0, N):
print(fibonacci(i), end ='')
6. Determine el número factorial para un número n determinado o ingresado por teclado.
N=int(input("LOSVALORES SON :"))

ACUMULADOR= 1
print((i+1), end= '')
ACUMULADOR=ACUMULADOR+(i+1)
print("=",ACUMULADOR)
7. Determine la potencia para un número n determinado o ingresado por teclado.
Página 35 de 63
X = int(input("UN NUMERO: "))
for L in range(1, X+1):
POT= X ** L
print(f"{X}^{L} = {POT}")
8. Elabore un menú para los ejercicios 4, 5, 6 y 7.
while True:
print("\n1.ACT 4")
print("2.ACT 5")
print("3.ACT 6")
print("4.ACT7")
print("5.TERMINADO ")
op = int(input(" VALOR ES: "))
if (op < 1 or op > 5):
print("OP. INVALIDA")
elif (op == 1):
print( )
print("4) Determine la secuencia ULAM:")
x = int(input("NUMERO : "))
if x == 0:
print("LA VALIDEZ NO ES")
else:
while x != 1:
if x % 2 == 0:
x = x / 2
print(x)
else:
x = x * 3 + 1
print(x)
elif (op == 2):

print("5) Determine la secuencia FIBO.")
nu = int(input("NUMERO:"))
print(f"CON LOS {nu} NUMEROS PRIMEROS")
o = 0
p = 1
n = 0
for m in range(1, nu + 1):
n = o + p
o = p
p = n
print(f"{n}", end=" ")
elif (op == 3):

print("6) Determine el FAC ")
x = int(input("NUMERO"))
fs = 1
for k in range(x):
fs = fs * x
x = x - 1
print(f"{fs} FAC ES EL CORRECTO:")
elif (op == 4):

x = int(input("NUMERO:"))
for l in range(1, x + 1):
po = x ** l
print(f"{x}^{l} = {po}")
Página 36 de 63
elif (op == 5):
print("TERMINADO")
break
9. Elabore un programa que encuentre el resultado de las Series de Taylor:
sum = 1
a = 1
term = 4
for i in range(1,term):
prod = 1
for j in range(1, i+1):
prod = prod * a
fact = 1
for k in range(1, i+1):
fact = fact * k
print("prod", prod)
print("fact", fact)
sum = sum + (prod/fact)
print(sum)
print("La suma es ", sum)
10. El método de multiplicación rusa consiste en multiplicar sucesivamente por 2 el

multiplicando y dividir por 2 el multiplicador hasta que el multiplicador tome el valor
1. Luego, se suman todos los multiplicandos correspondientes a los multiplicadores
impares. Dicha suma es el producto de los dos números. La siguiente tabla muestra el
cálculo realizado para multiplicar 37 por 12, cuyo resultado final es 12 + 48 + 384 =
444. Desarrolle un programa que reciba como entrada el multiplicador y el
multiplicando, y entregue como resultado el producto de ambos, calculado mediante
el método de multiplicación rusa.
Página 37 de 63
X = int(0)
MA = int(input("UN NUMERO:"))
AM = int(input("UN NUMERO:"))
Y= MA
Z= AM
while(Y != 0):
if(Y % 2 != 0):
x1 = X + Z
Y =int(Y/2)
Z =Z *2
print(f"FINALIZACION ES: {X}")
Página 38 de 63

OBJETIVO
Objetivo General:
Valor: ____ puntos.
utilizado.
CONCLUSIONES
RECOMENDACIONES
Docente:
Firma:
Página 39 de 63

Fecha:
Por
Muy
CRITERIO bueno
70%
de 40%
[Sentir] – Actuar
Reflexión

Responsabilidad
10% 20% 20% 20% 20%

plagio o copia
Formativa
Firma y nombre de:
Estudiante Profesor
Página 40 de 63
1. Elabore un programa que determine si un número es primo o no.
def primo(n):
cont = 0
for i in range(1, n + 1):
if (n % i == 0):
cont = cont + 1
if cont <= 2:
print(n, "es primo ")
return
for j in range(1,100+1):
primo(j)
2. Elabore un programa que muestre los números del 100 al 200 en bloques de cinco en
cinco, utilice las estructuras repetitivas for, while y do-while para demostrar que las
tres realizan el mismo resultado.
print("For")
for k in range(100,205,5):
print(k)
print("*"*60)
print("While")
nu= 100
while nu <= 200:
print(nu)
nu = nu + 5
print("*"*60)
print("Do- while")
b=100
while True:
print(b)
Página 41 de 63
b = b +5
if b > 200:
break
3. Elabore un programa que genere un número aleatorio.
import random as aleatorio

N= aleatorio.randint(0,20)
print(N)
4. Elabore un programa que redondee “hacia arriba” y “hacia abajo”.
import math
x = float(input("PONGA EL DECIMAL "))
print(f'''
HACIA ABAJO EL REDONDEO : {math.floor(x)}
EL REDONDEO HACIA ARRIBA: {math.ceil(x)}
''')
5. Elabore un programa que muestre los números pares comprendidos entre 10 y 20

inclusive.
A = 9
while A < 20:
A = A+1
if A % 2 == 0:
print(f"{A} ES PAR")
6. Elabore un programa que permita ingresar mi nombre.
nom = input("Ingrese su nombre ")

print(f"Que belleza {nom} ")
7. Elabore un programa que cuente la cantidad de vocales de una palabra.
def vocal (PALB):

VOCAL = "aeiouAEIOU"
return set([g for g in PALB if g in VOCAL])
palabra= input("UNA PALABRA: ")
print(f'''
{vocal(palabra)}
{len(vocal(palabra))}
''')
Página 42 de 63
8. Elabore un programa que cuente la cantidad de espacios vacíos de una frase.
FRA= input("LA FRASE ES:")

A=len(FRA)
B=0
C=0
while A < len(FRA):
if FRA[A] == " ":
C+= 1
A= A+1
print(f"Existen {C} ")
9. Elabore un programa que valide el número de cédula ecuatoriana.
cedula = '0941012585'
invertircedula = cedula[::-1]
print(cedula)
10. Implemente el siguiente juego: el programa seleccionará un número aleatorio entre 0

y 100 y el jugador debe acertarlo. En cada intento el jugador propondrá una solución
y se le informará si el número a acertar es menor o mayor que el propuesto. El juego
termina cuando se acierte la cifra o haya realizado un máximo de 12 intentos en cuyo
caso se le mostrará al jugador la calificación obtenida según la siguiente tabla:
Número de intentos Categoría
1-3 Suertudo
4-6 Genio
7 No está mal
8 Se puede mejorar
>= 9 Que pasa amigo
import random
oport=int(input("LA OPORTUNIDAD MAS DE 10"))
RAN = random.randint(1,100)
for A in range(1,oport):
NUM= int(input("NUMERO DESDE EL 1 AL 100"))
if NUM < RAN:
print(f"{NUM} ESTA ES MENOR")
elif NUM > RAN:
print(f"{NUM} ESTA ES MAYOR)
else:
print(f"Ganaste! {A} de tus {oport} OPORTUNIDAD")
break
if A>= 1 and A <=3:
Página 43 de 63
print('QUE SUERTE EH!')
elif A>= 4 and A <=6:
print('ESTA BIEN PERO PUEDES MEJORAR')
elif A == 8:
print("DALE OTRA VEZ BRO SI PUEDES")
elif A <=9:
print("¿QUE PASO BRO?")

OBJETIVO
Objetivo General:
Valor: _____ puntos.
utilizado.
CONCLUSIONES
RECOMENDACIONES
Docente:
Firma:
Página 44 de 63
Página 45 de 63

Fecha:
Por
Muy
CRITERIO bueno
70%
de 40%
[Sentir] – Actuar
Reflexión

Responsabilidad
10% 20% 20% 20% 20%

plagio o copia
Formativa
Firma y nombre de:
Estudiante Profesor
Página 46 de 63
1. Ingrese una cantidad que represente dólares, muestre a continuación el valor

correspondiente en euros. (1 dólar estadounidense = 0,897070169 euros).
DLRS= float(input("INGRESE LA CANTIDAD DE DLRS: "))

EUROS= DLRS* 0.897070169
print(f"${DLRS} en esuros son {EUROS}")
2. Ingrese tres valores de calificación sobre diez (notas de una materia), luego calcule su
promedio.
NOTA=float(input("LA NOTA ES"))

NOTA1=float(input("LANOTA ES"))
NOTA2=float(input("LA NOTA ES"))
EXCELENTE=(NOTA + NOTA1 + NOTA2)/3
print(f"TU PROMEDIO ES {EXCELENTE}")
3. Ingrese dos valores enteros, correspondientes a edades de personas, luego muestre en

pantalla cuál de las dos es mayor.
EDAD= int(input("Ingrese la primera edad"))

EDAD1= int(input("Ingrese la segunda edad"))
if (EDAD>EDAD1):
print(f"{EDAD} es mayor a {EDAD1}")
elif (EDAD1<EDAD):
print(f"{EDAD1} es mayor a {EDAD}")
else:
print("SON IGUALES LAS EDADES")
4. Ingrese un número del uno al siete, luego muestra su correspondiente día.
Página 47 de 63
DAY=int(input("UN NUMERO DEL 1 AL 7 "))
if DAY==1:
print("LUN")
elif DAY==2:
print("MAR")
elif DAY== 3:
print("MIE")
elif DAY==4:
print("JUE")
elif DAY==5:
print("VIE")
elif DAY==6:
print("SAB")
elif DAY==7:
print("DOM")
else:
print("INGRESO CORRECTO")
5. Muestra los números del 25 al 58 utilizando el lazo repetitivo “mientras” o “while”.
NUMERO= 25
while NUMERO<= 58:
print(NUMERO)
NUMERO = NUMERO + 1
6. Muestra los números del 74 al 96 utilizando el lazo repetitivo “hacer mientras ó hasta
que” o “do while ó repeat until”.
NUMERO= 74
while True:
print(NUMERO)
nu = NUMERO + 1
if NUMERO > 96:
break
7. Muestra los números del 11 al 99 en bloques de diez en diez utilizando el lazo

repetitivo “para” o “for”.
for NUMEROS in range(11, 99,10):

print(NUMEROS)
8. Ingrese una cantidad de x números del uno (1) al noventa y nueve (99), su programa
finaliza cuando el usuario ingresa –888. A continuación, se mostrará en pantalla
cuántos números son: impares, pares y primos.
Página 48 de 63
NUMERO = int(input("NUMEROS QUE USTED QUIERE:"))
A=[]
B=[]
for Y in range(1,NUMERO+1):
X=int(input("NUMERO DEL 1 al 99"))
if X==-888:
print("HASTA AHI NO MAS!")
elif X>=1 and X<=99:
if X%2 == 0:
K= B.append(X)
elif NUMERO%2 != 0:
L = A.append(X)
9. Realizar la sumatoria de los números del 20 al 30.
X=20
A= X
while X<29:
X=X+1
A=A+X
print(f"SU SUMA ES:{A}")
10. Realiza la simulación del lanzamiento de dos dados. Recuerda que son aleatorios el
valor a obtener y sólo puede generarse los números del 1 al 6.
import random
print(f'''
DADOSS1: {random.randint(1,6)}
DADOSS2: {random.randint(1,6)}
''')

Página 49 de 63
OBJETIVO
Objetivo General:
Valor: _____ puntos.
utilizado.
CONCLUSIONES
RECOMENDACIONES
Docente:
Firma:
Página 50 de 63

Fecha:
Por
Muy
CRITERIO bueno
70%
de 40%
[Sentir] – Actuar
Reflexión

Responsabilidad
10% 20% 20% 20% 20%

plagio o copia
Formativa
Firma y nombre de:
Estudiante Profesor
Página 51 de 63
A continuación, tiene bloques de códigos que representan la secuencia de creación de
archivos.
Archivo: ejercicios.py Archivo: principal.py
from math import *
# forma 1
# import funciones
print(" / ")
# funciones.menu()
print(" / ")
print(" / ")
# forma 2
print("/ ")
from funciones import menu, metodo1, factorial
menu()
###############################
character_name = "Joe"
character_age = "35"
age = 45
isMale = True
is_male = False Archivo: funciones.py
print(" Hola soy "+character_name+" Llerena")
def menu():
print(" y tengo "+character_age)
while True:
print("Su alumno es "+str(is_male))
opcion = input("Ingrese una opcion: ")
print("Su hermano tiene "+str(age)+" anios")
if opcion==1:
print ("metodo 1")
###############################
metodo1()
# Usando strings
elif opcion==2:
print (" Universidad \n Politecnica \n Salesiana")
print ("metodo 2")
frase = "Esto es un string o cadena de caracteres "
n = raw_input("Ingrese numero: ")
print (frase)
r = factorial(n)
print (frase.index("d"))
print ("resultado es "+str(r))
print (frase.replace("es","mira a"))
elif opcion==3:
print ("metodo 1")
###############################
elif opcion==4:
# visualizar numeros
print ("metodo 1")
my_num = -4
elif opcion==5:
print(str(my_num))
print ("metodo 1")
print (abs(my_num))
elif opcion==6:
print (str(abs(my_num)) + " es mi numero preferido")
print ("metodo 1")
print(pow(3, 2))
elif opcion==7:
print ("Salir")
my_num = 4
break
print (round(3.4))
print (floor(my_num))
def metodo1():
print (sqrt(my_num))
nombre = raw_input("Ingrese su nombre: ")
# get input de users
veces = input("Ingrese veces a repetir: ")
name = input("Ingrese su nombre ")
for i in range (veces):
age = input("Ingrese su edad ")
print (str(i+1) + " "+ nombre)
print ("Su nombre es " + name +" y su edad es "+ age)
def factorial(a):
num1 = input("Ingrese un primer numero ")
fac = 1
num2 = input("Ingrese un segundo numero ")
for i in range(1, int(a)+1):
result = num1 + num2 # no es correcto
fac = fac * (i)
result1 = int(num1) + int(num2) # es correcto
return fac
print (result)
print (result1)
Página 52 de 63
def menu():
while True:
opcion = input("Ingrese una opcion: ")
if opcion==1:
print ("metodo 1")
metodo1()
elif opcion==2:
print ("metodo 2")
n = raw_input("Ingrese numero: ")
r = factorial(n)
print ("resultado es "+str(r))
elif opcion==3:
print ("metodo 1")
elif opcion==4:
print ("metodo 1")
elif opcion==5:
print ("metodo 1")
elif opcion==6:
print ("metodo 1")
elif opcion==7:
print ("Salir")
break
def metodo1():
nombre = raw_input("Ingrese su nombre: ")
veces = input("Ingrese veces a repetir: ")
for i in range (veces):
print (str(i+1) + " "+ nombre)
def factorial(a):
fac = 1
for i in range(1, int(a)+1):
fac = fac * (i)
return fac
ANEXO
Los algoritmos y sus aplicaciones, puedes encontrarlos en las páginas de sus fabricantes.
Software DFD para generación de algoritmos

DFD representados en diagramas de flujo.
Site web: https://freedfd.uptodown.com/windows
Software Raptor para generación de algoritmos

Raptor representados en diagramas de flujo.
Site web: https://raptor.martincarlisle.com/
Software PseInt para generación de algoritmos

representados en seudocódigo y generación de
PseInt
diagramas de flujo.
Site web: http://pseint.sourceforge.net/
Página 53 de 63
Python Software de desarrollo de lenguaje interpretado.
Site web:
Python https://www.anaconda.com/
Prioridad
Site web:
Python https://www.jetbrains.com/pycharm/
Site web:
https://anaconda.org/anaconda/spyder
Spyder
Site web:
Google https://colab.research.google.com/notebooks/intro.ipynb
Colaboratory
Página 54 de 63
Finalización de este proceso
El trabajo no termina aquí, es constante y mejorable. Aprender

nuevas teorías, conceptos, estrategias y buenas prácticas requiere
de un esfuerzo del día a día.
Esperamos que esta Guía de prácticas de experimentación de

Programación, Unidad 1, haya sido de utilidad para complementar
tus conocimientos aprendidos en el aula de clases.
Te decimos ¡gracias! por ser creativo, proactivo, entusiasta y

dinámico en la forma de responder a este trabajo.
Que tu entusiasmo de aprender perdure.
Profesores del Claustro de Computación Aplicada y

Metodologías de la Computación
Página 55 de 63

GUIA PRACTICA DE LABORATORIO - Programación Anthony Angulo

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

GUIA PRACTICA DE LABORATORIO - Programación Anthony Angulo

Cargado por

Copyright:

Formatos disponibles

Prácticas de Experimentación de Programación

Guías prácticas para estudiantes

Claustro de Computación Aplicada

Joe Frand Llerena Izquierdo (Coordinador)

Universidad Politécnica Salesiana

Estas guías de laboratorio son el resultado de la preocupación y

Esperamos que estas Guías de Prácticas, te animen a desarrollar

Profesores del Claustro de Computación Aplicada y

Datos Informativos de la Asignatura..................................................................................................... 1

Lenguajes de Programación ................................................................................................................24

Lenguajes de Programación ................................................................................................................47

[1] Datos informativos

[2] Caracterización de la Asignatura

Dentro de la ingeniería, es necesario el análisis, diseño e implementación de una solución a un

[3] Resultados de Aprendizaje

Unidades Contenidos de la Unidad Resultados de Indicadores de Logro Total de

UNIDAD 3 Fundamentos Desarrolla aplicaciones Identifica la sintaxis y

Metodología “aula invertida”, es una metodología de aprendizaje semipresencial, donde los

El Aprendizaje basado en investigación, considera al estudiante como protagonista de su propio

Aprendizaje basado en proyectos.

[6] Procedimiento de Evaluación

Según el Reglamento Interno de Régimen Académico:

TEXTOS AUTOR; TÍTULO; EDICIÓN Y AÑO

Sugerencias antes de iniciar su trabajo académico:

Compartimos algunas recomendaciones que pueden ayudarte desde la experiencia

Carrera: Ingenierías Asignatura: Programación

RÚBRICA DE EVALUACIÓN DE LA PRÁCTICA 7

Las actividades académicas las he realizado con:

10% 20% 20% 20% 20%

TOTAL sobre 100% del puntaje asignado

Firma y nombre de:

def rellenar_matriz(filas, columnas, matriz):

def sumar_matriz (matriz, filasu, columnas, filas):

opcion=input("Introduce una Opción: ")

….. ahora siga usted completando el código necesario. Referencia:

enlace enlace enlace enlace

Se pueden resolver con listas bidimensionales algunos de los siguientes problemas:

for i in range (len(matriz)):

for i in range (len(matriz)):

4. Un cuadrado semi-mágico es una matriz cuadrada conteniendo números tales que la

Ejemplo. Matriz inicial de 4 x 4 Matriz rellena:

N = int(input("INGRESAR EL NUMERO: "))

def elvalcuadrado (N):

def secuenciade1 (N):

def secuenciade1 (N):

import random as aleatoria

print(f"EL CUADRADO ES {list}")

Carrera: Ingenierías Asignatura: Programación

RÚBRICA DE EVALUACIÓN DE LA PRÁCTICA 8

Las actividades académicas las he realizado con:

10% 20% 20% 20% 20%

TOTAL sobre 100% del puntaje asignado

Firma y nombre de:

1. Escriba un programa que muestre la siguiente figura:

2. Siendo a="Hola", b="mundo", c=87 y d=2.33145, armar y mostrar las siguientes

palb= "Esto es asi"

4. Hacer un programa que le pida un número al usuario (usando la función "input") y

5. Pedirle un número al usuario, elevarlo al cuadrado, y mostrar los dígitos al revés y

from math import pi

7. Pedirle un número con muchos decimales al usuario y mostrarlo redondeado a 3

10. Mostrar los números potencia de 2 menores a 10000 de la siguiente manera:

FRA= input("INGRESE LA FRASEE:")

13. Escribir un programa que le pregunte un número al usuario. Si el número es 5, que

MUE= input("EL NUMERO ES:")