TRABAJO FINAL DEL CURSO

Algoritmia de programación del software

ACTIVIDAD ENTREGABLE

Profesor: Remigio Huarcaya Almeyda

Alumno: Diego Alexander Trujillo Del Castillo

Carrera: Ingeniería en Software con Inteligencia Artificial

Segundo Semestre

2021
1
 TRABAJO FINAL DEL CURSO

1. INFORMACIÓN GENERAL:

Apellidos y Nombres: Trujillo del Castillo, Diego Alexander. ID: 001355620

Dirección Zonal/CFP: Luis Cáceres Graziani.
Carrera: Ingeniería en Software con Inteligencia Artificial. Semestre: 2do
Curso/ Mód. Formativo: Algoritmia de programación del software.
Tema del Trabajo: Creación de Aplicaciones básicas en Python.

2. PLANIFICACIÓN DEL TRABAJO:

N° ACTIVIDADES CRONOGRAMA/ FECHA DE ENTREGA TRABAJO FINAL

Indagación respecto al tema
1 Fecha 08 - 08 - 2021 Tiempo 45min
de la actividad.
Búsqueda de recursos y
2 fuentes amplias de Fecha 15 – 08 - 2021 Tiempo 2h
información.

3 Análisis del problema. Fecha 22 – 08 - 2021 Tiempo 30min

Colocación de los datos con

4 Fecha 29 - 08 - 2021 Tiempo 1h
la información buscada.
1
5 Resolución de preguntas. Fecha 26 - 09 - 2021 Tiempo 1 h
2

6 Revisión de los datos. Fecha 29 - 09 - 2021 Tiempo 30min

Verificación de los problemas

7 04 - 10 - 2021 15min
resueltos.

8 Decoración y detalles. Fecha 10 - 10 - 2021 Tiempo 1h

3. PREGUNTAS GUIA:
Durante la investigación de estudio, debes obtener las respuestas a las siguientes interrogantes:

Nº PREGUNTAS
¿Cómo se maneja las Cadenas, Operaciones y se crea colecciones de datos en
1
Python?
2 ¿Cómo generar Clases, Objetos y Funciones en Python?
¿Cómo crear una aplicación con el manejo de errores y gestión de expresiones
3
regulares?
4 ¿Cómo Estructurar una Base de Datos en Python?
5 ¿Cómo Generar una interfaz Gráfica con Tkinter?
6 ¿Cómo trabajar con módulos, ficheros de texto y binarios en Python?
¿Cómo generar documentación automáticamente y trabajar con pruebas
7
automáticas?

2
 TRABAJO FINAL DEL CURSO

OBJETIVO DEL TRABAJO

Evaluar la capacidad del estudiante para desarrollar aplicaciones básicas en Python
y herramientas elementales.

PLANTEAMIENTO DEL TRABAJO

Debido a la Pandemia la Ferretería “El Tornillo Feliz” desea implementar un sistema
de registros de pedidos por teléfono, para lo cual necesitar registrar el DNI, nombres
y apellidos, la dirección, teléfono y el pedido que se realiza. Al solo contar con una
computadora y escasos recursos, decide utilizar el Python.
Este sistema debe permitir no solo registrar estos datos, si no también imprimirlos
para que el repartidor los lleve sin problema.

Para lo cual presentará:

• La interfaz Gráfica con Tkinter para cumplir con las exigencias del usuario
• Diagrama de flujo y código fuente en Python que resuelva el requerimiento.
• Un informe del procedimiento desarrollado para resolver el problema
planteado.

3
 TRABAJO FINAL DEL CURSO

CÓDIGO:
from tkinter import *

root = Tk()
root.title('FERRETERÍA EL TORNILLO FELIZ')

miFrame = Frame(root)
miFrame.pack()
#------- Label y entry DNI --------------------------------
obtenerDni=StringVar()
lDni = Label(miFrame, text='DNI:')
lDni.grid(row=0, column=0, sticky='e', pady=5, padx=5)
tDni = Entry(miFrame,textvariable=obtenerDni)
tDni.grid(row=0, column=1, pady=5, padx=5)
#Todo esto se podría ver mas limpio y organizado creando una clase, pero para que
puedas entenderlo lo dejo así.
#Un saludo!
#------- Label y entry Apallido -----------------------------
obtenerApellido=StringVar()
lApellido = Label(miFrame, text='Apellido:')
lApellido.grid(row=1, column=0, sticky='e', pady=5, padx=5)
tApellido = Entry(miFrame,textvariable=obtenerApellido)
tApellido.grid(row=1, column=1, pady=5, padx=5)
#------- Label y entry Nombre -------------------------------
obtenerNombre=StringVar()
lNombre = Label(miFrame, text='Nombre:')
lNombre.grid(row=1, column=2, sticky='e', pady=5, padx=5)
tNombre = Entry(miFrame,textvariable=obtenerNombre)
tNombre.grid(row=1, column=3, pady=5, padx=5)
#------- Label y entry Diección -----------------------------
obtenerDir=StringVar()
lDireccion = Label(miFrame, text='Dirección:')
lDireccion.grid(row=2, column=0, sticky='e', pady=5, padx=5)
tDireccion = Entry(miFrame,textvariable=obtenerDir)
tDireccion.grid(row=2, column=1, columnspan=3, sticky='we',pady=5, padx=5)
#------- Label y entry Teléfono -----------------------------
obtenerTel=StringVar()
lTel = Label(miFrame, text='Teléfono:')
lTel.grid(row=3, column=0, sticky='e', pady=5, padx=5)
tTel = Entry(miFrame,textvariable=obtenerTel)
tTel.grid(row=3, column=1,columnspan=3, sticky='we', pady=5, padx=5)
#-------------------------------------------------------------
miFrame1 = Frame(root)
miFrame1.pack()
#------- Label y entry,s Código producto ---------------------
lCodigo = Label(miFrame1, text='Cod_Prod')
lCodigo.grid(row=4, column=0,sticky='e', pady=5, padx=5)
tCodigo1 = Entry(miFrame1, width=7)

4
 TRABAJO FINAL DEL CURSO

tCodigo1.grid(row=5, column=0, pady=5, padx=5)

tCodigo2 = Entry(miFrame1, width=7)
tCodigo2.grid(row=6, column=0, pady=5, padx=5)
tCodigo3 = Entry(miFrame1, width=7)
tCodigo3.grid(row=7, column=0, pady=5, padx=5)
#------- Label y entry,s Descripción ---------------------------
lDes = Label(miFrame1, text='Descripción')
lDes.grid(row=4, column=1,sticky='ew', pady=5, padx=5)
tDes1 = Entry(miFrame1, width=7, state="readonly")
tDes1.grid(row=5, column=1, pady=5, padx=5)
tDes2 = Entry(miFrame1, width=7, state="readonly")
tDes2.grid(row=6, column=1, pady=5, padx=5)
tDes3 = Entry(miFrame1, width=7, state="readonly")
tDes3.grid(row=7, column=1, pady=5, padx=5)
#------- Label y entry,s Unidad --------------------------------
lUni = Label(miFrame1, text='Unidad')
lUni.grid(row=4, column=2,sticky='ew', pady=5, padx=5)
tUni1 = Entry(miFrame1, width=7, state="readonly")
tUni1.grid(row=5, column=2, pady=5, padx=5)
tUni2 = Entry(miFrame1, width=7, state="readonly")#width número de caracteres
tUni2.grid(row=6, column=2, pady=5, padx=5)
tUni3 = Entry(miFrame1, width=7, state="readonly")
tUni3.grid(row=7, column=2, pady=5, padx=5)
#------- Label y entry,s Cantidad ------------------------------
lCantidad = Label(miFrame1, text='Cantidad')
lCantidad.grid(row=4, column=3,sticky='ew', pady=5, padx=5)
tCantidad1 = Entry(miFrame1, width=7)
tCantidad1.grid(row=5, column=3, pady=5, padx=5)
tCantidad2 = Entry(miFrame1, width=7)#width número de caracteres
tCantidad2.grid(row=6, column=3, pady=5, padx=5)
tCantidad3 = Entry(miFrame1, width=7)
tCantidad3.grid(row=7, column=3, pady=5, padx=5)
#------- Label y entry,s Precio --------------------------------
lPrecio = Label(miFrame1, text='Precio')
lPrecio.grid(row=4, column=4,sticky='ew', pady=5, padx=5)
tPrecio1 = Entry(miFrame1, width=7, state="readonly")
tPrecio1.grid(row=5, column=4, pady=5, padx=5)
tPrecio2 = Entry(miFrame1, width=7, state="readonly")#width número de caracteres
tPrecio2.grid(row=6, column=4, pady=5, padx=5)
tPrecio3 = Entry(miFrame1, width=7, state="readonly")
tPrecio3.grid(row=7, column=4, pady=5, padx=5)
#------- Label y entry,s Subtotal ------------------------------
lSubtotal = Label(miFrame1, text='Subtotal')
lSubtotal.grid(row=4, column=5,sticky='ew', pady=5, padx=5)
tSubtotal1 = Entry(miFrame1, width=7, state="readonly")
tSubtotal1.grid(row=5, column=5, pady=5, padx=5)
tSubtotal2 = Entry(miFrame1, width=7, state="readonly")#width número de caracteres
tSubtotal2.grid(row=6, column=5, pady=5, padx=5)
tSubtotal3 = Entry(miFrame1, width=7, state="readonly")

5
 TRABAJO FINAL DEL CURSO

tSubtotal3.grid(row=7, column=5, pady=5, padx=5)

#------- Label y entry,s Total --------------------------------
lTotal = Label(miFrame1, text='Total')
lTotal.grid(row=7, column=6,sticky='ew', pady=5, padx=5)
tTotal = Entry(miFrame1, width=7, state="readonly")
tTotal.grid(row=7, column=7, pady=5, padx=5)
#------ Botón guardar -----------------------------------------
guardar=Button(miFrame1, text='Guradar')
guardar.grid(row=8, column=3, pady=5, padx=5)

root.mainloop()

6
 TRABAJO FINAL DEL CURSO

HOJA DE RESPUESTAS A LAS PREGUNTAS

GUÍA
1. ¿Cómo se maneja las Cadenas, Operaciones y se crea colecciones de
datos en Python?
Las cadenas: se pueden delimitar con comillas simples (') o con comillas dobles (") La
función print (), muestra por pantalla el contenido de la cadena. • Operaciones: en el
caso de las operaciones combinadas, el orden de prioridad en que se llevan a cabo las
operaciones es idéntico al de las matemáticas tradicionales. Python nos permite
realizar las siguientes operaciones matemáticas:
• Suma +
• Resta –
• Multiplicación *
• División /
• División entera //
• Módulo (resto) %
• Potenciación **

Cuando en una fórmula aparecen

varias operaciones, Python las efectúa
aplicando las reglas usuales de prioridad
de las operaciones (primero
multiplicaciones y divisiones, después
sumas y restas). En caso de querer que
las operaciones se realicen en otro
orden, se deben utilizar paréntesis.

Una colección permite agrupar varios objetos bajo un mismo nombre. Por ejemplo, si
necesitamos almacenar en nuestro programa los nombres de los alumnos de un curso
de programación, será más conveniente ubicarlos a todos dentro de una misma
colección de nombre alumnos , en lugar de crear los objetos alumno1 , alumno2 , etc.

En Python existen tres colecciones básicas, a saber: las listas, las tuplas y los
diccionarios.

Listas
Una lista es un conjunto ordenado de objetos. Por objetos entendemos cualquiera de
los tipos de dato ya mencionados, incluso otras listas. Para crear una lista,
especificamos sus elementos entre corchetes y separados por comas.

Tuplas
Las tuplas, al igual que las listas, son colecciones ordenadas. No obstante, a
diferencia de éstas, son inmutables. Es decir, una vez asignados los elementos, no
pueden ser alterados. En términos funcionales, podría decirse que las tuplas son un

7
 TRABAJO FINAL DEL CURSO

subconjunto de las listas, por cuanto soportan las operaciones con índices para
acceder a sus elementos, pero no así las de asignación.

Diccionarios
Los diccionarios, a diferencia de las listas y las tuplas, son colecciones no ordenadas
de objetos. Además, sus elementos tienen una particularidad: siempre conforman un
par clave-valor. Es decir, cuando añadimos un valor a un diccionario, se le asigna una
clave única con la que luego se podrá acceder a él (pues la posición ya no es un
determinante).

Para crear un diccionario, indicamos los pares clave-valor separados por comas y
estos, a su vez, separados por dos puntos.

2. ¿Cómo generar Clases, Objetos y Funciones en Python?

Las clases proveen una forma de empaquetar datos y funcionalidad juntos. Al crear
una nueva clase, se crea un nuevo tipo de objeto, permitiendo crear
nuevas instancias de ese tipo. Cada instancia de clase puede tener atributos adjuntos
para mantener su estado. Las instancias de clase también pueden tener métodos
(definidos por su clase) para modificar su estado.

Las clases de Python proveen todas las características normales de la Programación

Orientada a Objetos: el mecanismo de la herencia de clases permite múltiples clases
base, una clase derivada puede sobre escribir cualquier método de su(s) clase(s)
base, y un método puede llamar al método de la clase base con el mismo nombre.

Los objetos pueden tener una cantidad arbitraria de datos de cualquier tipo. Igual que
con los módulos, las clases participan de la naturaleza dinámica de Python: se crean
en tiempo de ejecución, y pueden modificarse luego de la creación.

El constructor define la forma en que se crean los objetos de datos. Para crear
un objeto Fracción, tendremos que proporcionar dos piezas de datos, el numerador y
el denominador. En Python, el método constructor siempre se llama __init__ (dos
subrayados antes y después de init ) y se muestra en el Programa

8
 TRABAJO FINAL DEL CURSO

Para definir una función en Python se utiliza la palabra reservada def. A

continuación, viene el nombre o identificador de la función que es el que se utiliza
para invocarla. Después del nombre hay que incluir los paréntesis y una lista opcional
de parámetros.

3. ¿Cómo crear una aplicación con el manejo de errores y gestión de

expresiones regulares?
Python permite escribir una rutina que se ejecuta automáticamente cuando se genera
un error del sistema. Hay varias técnicas para solucionarlo como: Una de ellas y la
más básica es Declaración try except, si se comete un error dentro de try, se difunde
una excepción y de ahí se ejecuta el código de la declaración except. La siguiente
declaración es raise, este es para personalizar excepciones, este no detecta
exactamente un error sino una condición que se puede utilizar para evitar la situación.
De ahí tenemos la clase Execute error, cuando algo falla se presenta una clase
excepción arcpy.ExecuteError, este divide los errores para manejarlos de diferente
manera. Después tenemos un traceback que es una secuencia de comando más
grande y complejo, los modulos sys y tracback se pueden utilizar juntos para encontrar
la ubicación y causa más exacta del error.

4. ¿Cómo Estructurar una Base de Datos en Python?

En Python, el acceso a bases de datos se encuentra definido a modo de estándar en

las especificaciones de DB-API, que puedes leer en la PEP 249. Esto, significa que
independientemente de la base de datos que utilicemos, los métodos y procesos de
conexión, lectura y escritura de datos, desde Python, siempre serán los mismos, más
allá del conector.

En nuestro caso particular, utilizaremos MySQL, para lo cual, vamos a trabajar con el
módulo MySQLbd.

9
 TRABAJO FINAL DEL CURSO

A diferencia de los módulos de la librería estándar de Python, MySQLbd debe ser

instalado manualmente. Para ello, ejecutaremos el siguiente comando.

5. ¿Cómo Generar una interfaz Gráfica con Tkinter?

Una de las formas más sencillas que existen en Python para crear interfaces gráficas
GUI, es con la ayuda de Tkinter.

Las GUI a menudo usan una forma de programación OO controlada por eventos, el
programa responde a eventos, que son acciones que un usuario realiza. Las acciones
que realiza el usuario no son otra cosa que botones que son presionados.

10
 TRABAJO FINAL DEL CURSO

6. ¿Cómo trabajar con módulos, ficheros de texto y binarios en

Python?

Si sales del intérprete de Python y vuelves a entrar, las definiciones que habías hecho
(funciones y variables) se pierden. Por lo tanto, si quieres escribir un programa más o
menos largo, es mejor que utilices un editor de texto para preparar la entrada para el
intérprete y ejecutarlo con ese archivo como entrada. Esto se conoce como crear
un script. A medida que tu programa crezca, quizás quieras separarlo en varios
archivos para que el mantenimiento sea más sencillo. Quizás también quieras usar
una función útil que has escrito en distintos programas sin copiar su definición en cada
programa.

Para soportar esto, Python tiene

una manera de poner definiciones
en un archivo y usarlos en un
script o en una instancia del
intérprete. Este tipo de ficheros se
llama módulo; las definiciones de
un módulo pueden
ser importadas a otros módulos o
al módulo principal (la colección
de variables a las que tienes
acceso en un script ejecutado en el nivel superior y en el modo calculadora).

Un módulo es un fichero conteniendo definiciones y declaraciones de Python. El

nombre de archivo es el nombre del módulo con el sufijo .py agregado. Dentro de un
módulo, el nombre del mismo módulo (como cadena) está disponible en el valor de la
variable global __name__. Por ejemplo, utiliza tu editor de texto favorito para crear un
archivo llamado fibo.py en el directorio actual, con el siguiente contenido:
Python nos permite también trabajar con ficheros de dos formas diferentes. Uno de
ellos sería utilizando el módulo os, que nos facilita el trabajo con todo el sistema de
ficheros y directorios a nivel de Sistema Operativo. La segunda forma es más simple,
nos permite trabajar con ficheros manipulando su lectura y escritura a nivel de
aplicación, tratando cada archivo como un objeto.

11
 TRABAJO FINAL DEL CURSO

7. ¿Cómo generar documentación automáticamente y trabajar con

pruebas automáticas?
Tenemos que analizar y crear un código de forma automática utilizando el lenguaje de
programación que uno más domine ya que no solo se puede hacer con uno. Aparte
recordemos que las pruebas automatizadas tienen como objetivo detectar fallas en el
software evitando que una persona tenga que ejecutar las pruebas manualmente.

La persona utiliza una herramienta

para que luego la misma se realice
automáticamente y así no se
requiera la intervención del
individuo en cada nueva ejecución
ya que la prueba simula la
interacción humana con el software.

12
 TRABAJO FINAL DEL CURSO

HOJA DE PLANIFICACIÓN
PROCESO DE EJECUCIÓN

PASOS /SUBPASOS

Paso 1: Descargar guía de trabajo:

Subpaso 1: Encender la PC
Subpaso 2: Abrir el navegador web
Subpaso 3: Ingresar a la plataforma blackboard de SENATI.
Subpaso 4: Buscar el curso de Algoritmia de programación del software.
Subpaso 5: Descargar el documento del curso.
Paso 2: Análisis del problema del programa:
Subpaso 1: Abrir el programa informático Microsoft Word para resolver el trabajo.
Subpaso 2: Contar el número de páginas.
Subpaso 3: Tener en claro, que es lo que me pide el problema.
Subpaso 4: Revisar la cantidad de preguntas del documento.
Subpaso 5: Una vez analizado, preparar las hojas de Word para la búsqueda de
información
Paso 3: Búsqueda de información de fuentes para el desarrollo:
Subpaso 1: Revisar los problemas y .
Subpaso 2: Entrar a google Chrome.
Subpaso 3: Buscar páginas de referencia enfocadas en base del problema.
Subpaso 4: Utilizar la información para resolver el programa.
Subpaso 5: Una vez obtenida la información, usarla para el desarrollo.
Paso 4: Desarrollo el programa y las preguntas:
Subpaso 1: Abrir el programa informático Microsoft Word para resolver el trabajo.
Subpaso 2: Abrir VS Code para realizar el programa.
Subpaso 3: Abrir MySQL.
Subpaso 4: Usar el Tkinter.
Subpaso 5: Activar XAMMP
Paso 5: Verificación final del documento.
Subpaso 1: Dar otro revisión a todo el archivo de la tarea.
Subpaso 2: Revisar el programa.
Subpaso 3: Revisar la BD de MySQL.
Subpaso 4: Rectificar los errores.
Subpaso 5: Verificar las respuestas y la ortografía.

INSTRUCCIONES: debes ser lo más explícito posible. Los gráficos ayudan a transmitir
mejor las ideas. No olvides los aspectos de calidad, medio ambiente y SHI.

13
 TRABAJO FINAL DEL CURSO

LISTA DE RECURSOS

INSTRUCCIONES: completa la lista de recursos necesarios para la ejecución del trabajo.

1. MÁQUINAS Y EQUIPOS
-Celular
-Laptop

2. HERRAMIENTAS E INSTRUMENTOS
-Visual Studio C
-MySQL

3. MATERIALES E INSUMOS
-Grabaciones de las clases.
-Páginas de información respecto al tema.

14