Programando Con Python - Problemario VF

Pág.
1
Programando con Python: Problemario López Marín, Miguel
Programando con Python:

Problemario
Ejercicios propuestos y
resueltos desde Cero,
sumergidos en el
mundo de Python + GUI
LOPEZ MARIN, MIGUEL

UNELLEZ
Pág. 2
Texto didáctico orientado al Fomento y Aprendizaje de la

Programación, en Lenguaje de Programación Python,
contiene ejercicios propuestos y resueltos desde cero,
texto orientado al Subproyecto Algoritmos y
Programación I, de la carrera Ingeniería Informática
UNIVERSIDAD NACIONAL EXPERIMENTAL DE

LOS LLANOS OCCIDENTALEZ "EZEQUIEL
ZAMORA"
Edición, Diseño y Desarrollo

LOPEZ MARIN, MIGUEL ANGEL
Ingeniero en Informática N° C.I.V. 236535
Docente Dedicación Exclusiva
Año 2020.
Creación Intelectual N° xxx xxx xxx Resolución

Consejo Académico N° en fecha xx xx xxxx
Pág. 3
Pág. Índice de Contenido

11 Prefacio
12 Metodología empleada
14 ¿Por qué Elegir Python para empezar a Programar?
15 Python Interactivo
16 Editores para Python
17 La Simplicidad de Python
19 Sintaxis en Python
20 Extensión de código Nativo en Python
CAPÍTULO I
22 Variables
22 Identificadores
23 Asignación de datos
24 Intercambiar valores de una variable
24 Tipos de datos
25 Inicialización de variables
00 Ejercicio 0001: ¡Hola Mundo!, Primer programa
27 Documentación del código fuente
28 Tipos y Manejos de errores
36 Palabras reservadas en Python
36 Ejercicio 0002: Sumar 2 números
37 Ejercicio 0003: Suma 2 números leídos por teclado
Pág. 4
38 Ejercicio 0004: Leer nuestro nombre y saludarnos

39 ¿Cómo se usa un método (función) propia del lenguaje Python?
39 Función print
40 Función input
40 Operadores aritméticos
41 Ejercicio 0005: Obtener un promedio de varias notas
42 Programación en escalera
42 Ejercicio 0006: Determinar la paga de una venta de leche en
galones
43 Definición de una función, construcción e invocación
44 Clausula return
44 Nuestra Primera Función hecha en Python
44 Ejercicio 0007: Calcular la edad de una persona
46 Calculando el Mayor de tres Números: 2 enfoques
46 Ejercicio 0008: Mayor de 3 enfoque 01
47 Ejercicio 0009: Mayor de 3 enfoque 02
48 Condiciones: simple, dobles y anidadas
49 Ejercicio 0010: Determinar la nota final de un alumno
51 ¿Cómo se debe formular los cálculos de un porcentaje?
52 Pase de argumentos y recepción de argumentos
53 Ejercicio 0011: determinar aproximadamente cuántos meses,
semanas, días y horas ha vivido una persona
Pág. 5
54 Ejercicio 0012: determinar si un número es positivo o negativo

Enunciados de problemas, casos cotidianos
54 Ejercicio 0013: contiene compras, descuentos y condiciones
55 ¿Acaso existe una única forma de Programar o resolver un
problema mediante el uso de la Programación?
56 Resolviendo el mayor de 3 números, de tres maneras
57 Ejercicio 0014: Generar presupuesto de ventas de comida,
contiene varios cálculos y condiciones
58 Ejercicio 0015:Cálculos varios, condiciones, relacionado a ventas
de uvas según tipo y tamaño
59 Ejercicio 0016: Cobros por servicios, viajes en autobús, cálculos
varios y condiciones
61 Uso de la función Round
61 Ejercicio 0017: Un centro de comunicaciones, contiene diversos
costos por minuto, emplea condiciones y cálculos varios
64 Función in, aplicabilidad
64 Ejercicio 0018: Compañía presta servicios, viajes en buses, uso de
condiciones, cálculos varios
66 Ejercicio 0019: Caso de un consultorio médicos, cobranzas por
citas, condiciones y cálculos varios
67 Ejercicio 0020: Problema de fábrica, costos, ventas, cálculos
varios y condiciones
Pág. 6
69 Recursividad
70 Ejercicio 0021: Servicio de encomiendas por zonas, cálculos
varios, recursividad, condiciones
CAPITULO II
74 Bucles
75 Ejercicio 0022: Mostrar las letras que tiene el nombre de una
persona, una letra a la vez
75 Ejercicio 0023: Dado un nombre, determinar el tamaño(n) de la
cadena, y mostrarlo (n) veces
Más funciones en Python
76 Eval
77 Range
78 Break
79 try except
Tratamiento de cadenas
81 Función len
82 Concatenar cadenas
82 Convertir cadena a mayúsculas, función upper
83 Convertir cadena a minúsculas, función lower
83 Eliminar ultimo carácter de una cadena
83 Mostrar una cadena en forma de lista
84 Convertir una cadena a una lista
Pág. 7
84 Contadores y Acumuladores
85 Ejercicio 0024: Realizar un programa que permita contar los
números pares entre el 50 y el 100 y sumar estos valores
85 Variables Booleanas
86 Validaciones
86 Ejercicio 0025: Validación de un email, varios criterios
89 Ejercicio 0026: Desarrollo de una calculadora básica
91 Ejercicio 0027: rutina de clave de acceso
91 Ejercicio 0028: Clave de acceso con control de intentos fallidos
93 Ejercicio 0029: Programa que sume los Números ingresados por
teclado
94 Ejercicio 0030: Calcular la nota definitiva de un alumno, con el
promedio de 5 notas.
94 Ejercicio 0031: Programa que muestra un nombre tantas veces se
solicite
95 Ejercicio 0032: Muestra una tabla de multiplicar elegida por el
usuario
96 Ejercicio 0033: Genera y muestra la tabla de multiplicar completa
96 Ejercicio 0034: Programa que permita calcular la nota final de n
alumnos y su literal
98 Ejercicio 0035: Programa que permita calcular el número mayor y
menor de una lista
Pág. 8
100 Ejercicio 0036: Programa que permite calcular el mayor de 3

números, tantas veces como lo desee el usuario
101 Ejercicio 0037: Divorcia una mujer si está casada
CAPITULO III
106 Preámbulo del Capitulo
106 Importando librerías en Python
107 Estructura de datos
108 Diccionarios
108 Tuplas
109 Empaquetado y desempaquetado de tuplas
109 Ejercicio 0038: cálculo de edad de una persona, contiene tuplas,
funciones y documentación
111 Listas
Actualización y consultas en estructuras de almacenamiento
111 Función append
112 Función remove
112 Función index
113 Ejercicio 0039: dado 2 listas, efectuar consultas, contiene uso de
funciones, clausula index y documentación
114 Metodo de Ordenación
114 Ejercicio 0040: listas con alumnos, aplicar método de ordenación
por burbuja, además contiene funciones y documentación
Pág. 9
117 Ejercicio 0041: Cargar 7 números por teclado, contiene métodos

de ordenación por inserción y por burbuja, documentación.
119 Ejercicio 0042: dado 2 listas de frutas, ordenar según criterio de
usuario, contiene método de ordenación por inserción.
120 Funciones estéticas o decorativas
121 Ejercicio 0043: programa que lea nombres y al imprimir estos se
aplica función decoradora, contiene funciones y documentación
121 Ejercicio 0044: Similar al ejercicio 0043, pero agregas más
elementos como saludar, emplea funciones decoradoras
123 Ejercicio 0045: listas con productos precargados para simular
proceso de ventas, contiene validación y manejo de errores.
125 Ejercicio 0046: Programa de ventas similar a una bodega,
contiene funciones decoradoras, validaciones, manejo de errores
127 Ejercicio 0047: Emula un sistema de votación, contiene diversos
parámetros, menús con opciones, validaciones, manejo de errores,
uso de listas, actualizaciones, lógica de programación y Haber
resuelto todos los ejercicios anteriores
136 Ejercicio 0048: emula un sistema de manejo de cuentas bancarias,
depósitos y retiros, contiene menús, y el nivel de exigencia similar
al Ejercicio 0047.
CAPITULO IV
146 Interfaces Graficas
Pág. 10
146 Librería tkinter

147 Mi primera ventana
149 Etiqueta o label
150 Empaquetado y visualización de etiquetas y cajas de texto
150 Caja de texto o entry
150 Ejercicio 0049: Interfaz gráfica, con algunos métodos tales como
fondo, dimensiones y titulo
152 Botones
152 Ejercicio 0050: Interfaz gráfica, contiene cajas de textos, etiquetas
y botones
154 Método get
154 Método set
154 Variables: StringVar(), IntVar(), DoubleVar()
154 Ventanas emergentes
154 Ejercicio 0051:Interfaz gráfica con etiquetas y cajas de texto y
programación de funcionalidad de boton
158 Bibliografía Consultada
Pág. 11
Prefacio
La Programación es un mundo fascinante para todo aquel que se
sumerge y se deja empapar de ese gusto, como las demás cosas de la
vida, programar también es un arte; se debe tener presente que algunas
personas desarrollan ciertas destrezas en algunas áreas del conocimiento
mientras que para otros esas destrezas y habilidades se ponen cuesta
arriba. Programar es como el que descubre que le gusta pintar, al cantante
que le gusta la música y al sastre la costura.
Las destrezas y habilidades para Programar se desarrollan
progresivamente y por el empeño, algunas se dan de forma empírica otras
por ser constante, perseverante; aquí en este punto se permite afirmar
que para desarrollar el potencial y aptitudes necesarias en programación
hay que dedicarse, por lo general no será un arte que se desarrolle de la
noche a la mañana, pero a quien le gusta y le apasiona, va resaltar y
seguramente será exitoso; este Texto está orientada a cualquier persona
que quiera iniciarse en la Programación y especialmente a mis Alumnos de
Programación I de la carrera de Ingeniería en Informática.
Vale acotar, que, para efectos de este Texto, es deseable que el
alumno distinga algunos aspectos básicos al menos conceptualmente, tales
como: algoritmo, resolución y planteamiento de ejercicios básicos en
seudocódigo, variables, estructuras secuenciales, bucles, arreglos y
conocimientos básicos en matemática a nivel de bachillerato.
El Texto fue concebido en aras de contar con un material de
consulta, actualizado y sobre todo desarrollado, desde el seno de Nuestra
querida Universidad, tomando en cuenta las diversas experiencias del
autor en Programación y en el dictado del Subproyecto Algoritmo y
Programación I, de tal manera que todo discente y docente en esta etapa,
pueda tomar este Texto como una referencia y material de apoyo para
alcanzar el logro de los objetivos que se desean en Programación I e
igualmente poder despejar dudas, inherentes al abordaje y desarrollo de
un ejercicio de Programación que este comprendido en este Nivel.
LOPEZ MARIN, Miguel Ángel
Pág. 12
Metodología empleada
Se proponen ejercicios y explicaciones conceptuales ilustradas con

ejemplos acerca de las funciones, semántica y sintaxis en Lenguaje de
Programación Python. Los Problemas se abordan atendiendo la lógica de
programación de cada enunciado basado en la propia experiencia del autor
como programador, desarrollador en ámbito académico y dictando el
Subproyecto Algoritmo y Programación I en la Universidad Nacional
Experimental de los Llanos Occidentales "Ezequiel Zamora".
Igualmente, en todo momento el discente podrá interactuar con la
propia interfaz nativa de Python o en la Herramienta Thonny para modificar
o corregir algún problema, con base a su propia experiencia, así como las
destrezas, aptitudes y habilidades que pueda desarrollar leyendo y
poniendo en práctica este Texto, en combinación con otros recursos a
disposición del discente bien sea en la web u otros medios.
Además, si intenta resolver los ejercicios propuestos acá por cuenta
propia, dispondrá de la solución en todo momento tanto en el Texto en
formato pdf, como el código fuente de cada programa en digital en
Lenguaje Python; todo problema propuesto está acompañado de la
solución completa y documentada. Tanto el Texto como el código fuente
de los programas, están disponibles en el blog
solucionaplicativa.blogspot.com, libre acceso y distribución para su
uso con los fines aquí dispuestos.
Para una mejor comprensión y didáctica en el texto, se emplean
varios colores en su desarrollo, los cuales se indica el significado a
continuación:
Texto color negro: conceptualización acerca de Semántica y

sintaxis en Lenguaje Python así como enunciados de ejercicios y otros
asociados al desarrollo del problemario como la introducción, metodología
empleada y prefacio del Texto.
Pág. 13
Texto color azul: permite resaltar algunas breves explicaciones,

contenidos alojados en tablas y pequeños aspectos importantes, el índice
del texto, además vale resaltar que el azul es el color corporativo del
Lenguaje Python
Texto color rojo: Enumeración de cada problema, para una

ubicación rápida en cualquier momento, además cada problema estará
enunciado brevemente en el índice.
Texto rojo oscuro: se reflejará las explicaciones dadas por el autor

acerca de la solución del problema y del Código en Lenguaje de
programación Python empleado para cada programa.
Texto color morado: enunciado de títulos de funciones, sintaxis y

títulos de conceptualización asociada al desarrollo del texto, también estará
presente en la Pagina Inicial de cada Capítulo enunciando los contenidos
dispuestos.
Texto color gris: indica el código de cada programa en Lenguaje

Python versión 3.8.2 la más actualizada para el momento del desarrollo
de este texto, bien sea ejecutado desde su interfaz interactiva (prompt) o
editado en su entorno de edición y que tal como se observa en el texto
funciona y cumple con los requisitos de cada enunciado en cuanto a lo que
plantea cada problema y lógica de programación.
Texto color verde claro, el código fuente necesario empleado

para interfaces graficas en el Capítulo IV de este libro, bien sea desde la
consola interactiva o desde el modo de edición
Pág. 14
¿Por qué Elegir Python para empezar a Programar?
En mi Modesta experiencia como Programador en ámbito

académico, he podido tener la experiencia de trabajar con distintos
Lenguajes de Programación, algunos oportunos en su momento y que hoy
en día me permito afirmar, varios de ellos, ya no representan las
tendencias o la evolución en cuanto a la enseñanza de Lenguajes y estilos
de Programación.
Algunas de mis experiencias y conocimientos en cuanto a lenguajes
tenemos: Pascal, Cobol, Qbasic, Microsoft Visual Fox Pro, C, C++, Python,
Java, Lenguaje de etiquetas HTML5, Php, Javascript. De todas estas
opciones, a pesar que cada una tiene su propia área de aplicación y
algunos son muy diversas, de todos escogería Python, por su versatilidad,
modernidad, multiplataforma, potencia, es minimalista, todo terreno, ideal
para iniciarse en programación, excelente para continuar a un nivel
intermedio con interfaces gráficas, una máquina que dispone de su propio
servidor para probar Desarrollos en ambiente web, en general es una
Lenguaje bastante completo, robusto y con una amplia bibliografía y
comunidad de programadores. Vale la pena también destacar que Python
viene instalado por defecto en diversos sistemas operativos.
Python por casualidad empecé a valorarlo, estudiarlo y me
engancho, al punto que uno de mis desarrollos académicos en pro de la
comunidad Unellence lo desarrolle en Python, Cerval Sim ulador ,
disponible en solucionaplicativa.blogspot.com. El lenguaje de
Programación Python, gano de este servidor todos los elogios, me permito
afirmar que es de los más robustos, sencillo y fácil de aprender, al menos
desde la óptica de lo que requiere un estudiante que finaliza su semestre
en su primera Programación y mucho más allá; vale resaltar que su sintaxis
es elegante, orientada a una correcta lectura, no requiere compilación, es
un lenguaje interpretado, también cuenta con algunos framework para
desarrollar aplicaciones web y de escritorio tales Django, Pyramide, Flask,
entre otros.
Pág. 15
Python Interactivo
Python permite ejecutar código directamente desde su consola
interactiva, apenas abrimos Python >>> el indicador también llamado
prompt, está listo para recibir instrucciones y dar respuestas;
excepto editar cómodamente, esa tarea se deja al editor.
Desde la consola interactiva, en el (prompt), podemos

ejecutar y probar funciones, definir variables, mostrar mensajes, definir
una lista, tupla o diccionario. Prácticamente se puede realizar cualquier
operación básica desde el Prompt; a modo de ejemplo, si en Python
queremos sumar 2 números desde el intérprete, basta con teclear esa
orden como si fuera una calculadora, una vez culminamos la
instrucción en una línea, para continuar en la otra pulsamos la
tecla enter o para esperar la respuesta del interprete; vale destacar
que el prompt se ejecuta apenas abrimos Python es lo primero que
miramos >>>:
>>> 2+2
4
>>>
Si por ejemplo queremos definir 3 variables y luego sumarlos sería

algo así:
>>> a=5
>>> b=8
>>> c=10
>>> a+b+c
23
>>>
Obsérvese, que he definido 3 variables cada una con un valor, a=5,
b=8, c=10, luego sume esas 3 variables, al presionar la tecla enter el
prompt muestra el resultado (23) para este ejemplo. Tanto en el interprete
Pág. 16
como en el editor de Python las variables se van usando y en función de

ello estas asumen el tipo de dato que almacenan, solo se indica el tipo,
cuando se efectúen lecturas de variables, a diferencia de otros lenguajes
como C y C++; aquí no se hacen declaraciones previas para el uso de
variables ni llamado de librerías básicas o directivas al estilo de estos
lenguajes al menos no hasta el contenido básico, en función de la
complejidad del ejercicio se importaran algunos módulos, pero su sintaxis
es muy fácil.
Para efectos del Texto y en el momento de desarrollarlo estaremos
trabajando con la versión de Python 3.8.2 que sería la última versión
publicada en el sitio web oficial http:/ / w w w .python.org , en lo
consecuente podemos trabajar directamente en Python o también con el
Software Thonny el cual se instala con este una versión de Python para
el momento la 3.7.7 y es bastante sencillo, minimalista permite configurar
temas para efectos de comodidad y trae varias asistencias. En ambos casos
el desarrollo y código que se ejecute funcionara igual.
Editores para Python

Python cuenta con su propio editor, igualmente para la edición de
programas con asistencia de código, resaltado y otras comodidades y
escribir programas completos, se cuenta con herramientas IDE (entornos
de desarrollo) potentes y Programación a Escala de Inteligencia artificial y
científica como Spyder(Anaconda), Komodo y amigables tales como Ninja,
Thonny; además, se dispone de Editores con opción a ejecutar código
Python como Sublime Text3, Visual studio code, o Notepad++, existen
muchas, pero estos en especial los recomendaría, un buen editor es
minimalista y tiene innumerables asistencias en la edición e interpretación
de ese código.
Tanto la interfaz interactiva de Python, desde el prompt,
como el editor, no tienen asistencia de sintaxis, más allá del hecho que
cuando se va ejecutar el código te avisa de los posibles errores, sin
embargo, como en todo lenguaje, un programa que corra (ejecute) no
significa que funciona correctamente o resuelva el problema planteado. El
Pág. 17
elegir un entorno de desarrollo o un editor profesional depende en gran

medida de la experiencia del programador y como se sienta más a gusto,
para empezar, debe iniciarse en el editor de Python, por mucho con
Thonny y luego si escalar en función del desarrollo de habilidades, Python
incluso desde su propio editor permite ejecutar código de forma veloz,
resultados similares cuando se está trabajando con interfaces gráficas. En
todo caso lo que prevalece en una acertada decisión es la comodidad del
Programador.
La Simplicidad de Python
Antes de empezar debemos tener claro un aspecto que se refiere a
las Características Básicas de Python una de ellas es que maneja un tipado
dinámico y su código se interpreta no se compila. Significa que el código
se traduce línea por línea a lenguaje máquina, mientras se va ejecutando,
en lenguajes compilados aparte que las variables a usar, todas se declaran
previamente, primero se traduce a lenguaje maquina todo el
codigo(compilación) y se guarda un archivo para su ejecución cuando se
requiera.
En Lenguajes de Programación como C++, si nosotros deseamos
sumar dos números leídos por teclado y mostrar el resultado sería algo así:
Ejemplo. C++
Pág. 18
Mientras que en Python se vería de la siguiente forma:
Ejemplo. Python
Observando la diferencia es abismal, para el mismo ejercicio con

C++, consumió 11 líneas sin contar con el hecho de que la lectura de los
dos números está escrita en la misma línea, en Python solo se necesitó de
5 líneas. Pero más allá de la cantidad se acotará lo siguiente: C++ Es un
Lenguaje Estático y Compilado. Al tener esta condición todas las variables
que se empleen deben declararse previamente y su respectivo tipo de
dato.
En Python todos los valores que se leen por defecto son
tratados como una cadena, excepto que se le aplique otro trato
mediante funciones y argumentos a esta. Fijémonos que luego de
haberse leído ambas variables (valor1, valor2), justo al momento de
sumarse es que convierto las cadenas leídas en un tipo de dato entero, si
bien se pudo haber hecho al momento de leerlas. También vale acotar lo
siguiente si hubiésemos asignado previamente valores a 2 variables, algo
así como:
a=20
b=10
c=a+b
print(c)
Ni siquiera hubiese requerido convertir ninguna cadena, este

ejemplo solo sería posible en un Lenguaje con tipado dinámico y código
interpretado, no requiere que se compile previamente, este es el caso de
Python. Si alguien ejecutase las 4 líneas anteriores, le mostraría como
Pág. 19
resultado un 30, y eso pasa por que en Python los datos son tratados tal
como se observan según el valor asignado a la variable, si le asignas una
cadena, lo tratara como cadena y así para los otros tipos de datos como
los reales.
En resumidas cuentas, y sin caer en tecnicismo, es más sencillo,
practico y un poco más innovador para alguien que se inicie en
Programación emplear Python. Vale aclarar que más allá de la simplicidad
este Lenguaje es extremadamente potente y grandes de la Tecnología
como Amazon, Google, NASA, Instagram por nombrar algunos emplean en
buena parte de su plataforma código Python, sobre todo del lado de sus
servidores, Sublim edit3 y Thonny están escritos en Python.
Sintaxis en Python
Aunque poco a poco podremos ir observando y apreciando la forma
de escribir código en Python vale aclarar que, a diferencia de otros
lenguajes, en Python cada línea NO finaliza en punto y com a
";"simplemente no lleva así de sencillo, tam poco usa llaves "{ } " , en
cambio emplea algo que se denomina indentación, sangrado o
tabulación de 4 espacios para identificar que líneas van dentro de un
bloque de instrucciones o condiciones. En un entorno profesional como
Spyder(Anaconda), incluso el mismo Sublim Text3 o el minimalista Thonny,
automáticamente él te deja el sangrado correspondiente al iniciar un nuevo
bloque que va dentro de otra condición o criterio. Aunque la decisión final
y la lógica del código depende del programador, las asistencias en el
desarrollo no son la letra final.
En Python no es lo mismo escribir hola, HOLA, Hola, al menos no
empleándolo como variables o en funciones, este lenguaje es
sensible al uso de mayúsculas y minúsculas y a diferencia de otros
lenguajes, permite el uso de mayúsculas y minúsculas, caso distinto
en el uso y empleo de palabras reservadas e importación de módulos
donde se emplea en minúsculas, hay ciertas excepciones que no
necesariamente vienen al caso como al emplear el Modulo de Tkinter que
Pág. 20
es la Interfaz gráfica por defecto que viene con Python allí buena parte de
su sintaxis es Mixta( emplea mayúsculas y minúsculas).
El uso de los dos puntos: Todo inicio de una condición o bloque

de código finaliza con dos puntos (:), veamos un ejemplo:
if a > b:
mayor=a
Aunque bastante sencillo el ejemplo anterior, el fin es ilustrar el uso

de los dos puntos y así sucesivamente se hace con el final de la primera
línea, al iniciar cualquier bloque de código, y luego todas las líneas del
bloque llevan indentación para indicar que pertenecen a ese bloque. La
indentación aparte que es una regla obligatoria en Python ayuda a leer y
comprender el código de una forma un poco más amena y cómoda.
Uso de comentarios: en este lenguaje existen 2 formas de hacer

un comentario, está el comentario de una sola línea que se emplearía para
iniciarlo lo que se conoce como Numeral (#) y en otros países le
denominan almohadilla, y el comentario de varias líneas que iniciaría con
triple comilla simple o doble, seria así:
#Mi primer comentario
""" Un comentario de Varias líneas o muy extenso y que ocupa

mucho espacio """
Extensión de código Nativo en Python

Todos los archivos nativos de Python se almacenan con la extensión
(py), es importante resaltar que si el scrip o código fuente de nuestro
programa está editándose en un editor ajeno al que viene por defecto en
Python, debemos verificar que al guardar nuestro código, este finalice con
la extensión (.py), debe tomarse como una regla.
Pág. 21
Capítulo I
Variables
Identificadores, Asignación, Tipos de datos,
Inicialización de variables
Manejo de errores, Documentación
Funciones Básicas del Lenguaje

print, input, if elif else, round, in
Manejo de los tipos de datos en Python
Operadores:
Aritméticos, de comparación y Lógicos
Definición e invocación de Funciones
Condiciones
Simples, dobles, anidadas y compuestas
Recursividad
Pág. 22
Al igual que en muchos lenguajes de Programación, en Python, la

sintaxis es similar para efectos de operadores aritméticos, de asignación y
de comparación. Para no saturar de una sola vez todo al respecto, se ira
abordando en función de cómo se vaya necesitando para que el discente,
pueda continuar y no estarse devolviendo a un punto anterior de este texto
problemario.
Vale destacar que nuestros programas los escribiremos en modo de
edición en la mayoría de los casos, resulta más práctico y seria lo correcto,
solo para ejemplificar aspectos muy rápidos o ejemplificar funciones y
clausulas, se empleara la consola interactiva desde el prompt, por cierto
para salir de la consola tenemos 4 opciones o la cerramos
haciendo clic en la x de la ventana superior derecha o vía
comando tecleamos en el prompt la instrucción quit(), igual
efecto tendría exit(), con estas 2 ultimas nos saldrá un cuadro de
diálogo y aceptamos, también es válido pulsar las teclas ctrl
seguido de la letra q (ctrl+q).
La idea es que lo que se vaya proponiendo se vaya haciendo,
dejando de lado algunos tecnicismos y no dedicándonos con énfasis al
editor, nos centraremos en solucionar los problemas propuestos, y explicar
con detalle cada función e instrucciones en Python, iniciaremos:
Variables
Una variable es un espacio reservado en la memoria del equipo que
permite almacenar un tipo de dato. El uso de variables es imprescindible
en la programación para un manejo eficaz de la información. Vale recordar
que existen variables locales y variables globales, las primeras solo
existen en la función donde son declaradas y las globales pueden ser
empleadas en cualquier lugar de un bloque de código o instrucciones.
Identificadores
Al hablar de variables tocamos también un tema asociado los
identificadores, estos se refieren al nombre que le damos a una variable
Pág. 23
o una función, en Python el identificador de una variable puede iniciar con

una letra mayúscula o minúscula, también puede contener números.
No se debe y no lo permite el lenguaje: emplear espacios en el
nombre de una variable, iniciar la identificación con números o símbolos
especiales, ni contener estos últimos en su composición.
Identificadores correctos Identificadores incorrectos

nombre 1nombre
Nom_Ape Nom ape
Porce25 25_porce
l1 1l
l2 m2%/
l3 variable_25 $#
sueldo sueldo neto
Asignación de datos
Simple
Para asignar un dato a una variable basta con escribir la variable,
siguiendo la lógica de sintaxis para identificarla, luego escribimos el signo
igual y escribimos su valor, si es una cadena se coloca entre comillas.
cadena="Miguel Angel"
entero= 25
numeroreal=250.75
Múltiple
También se permite efectuar una asignación múltiple con igual y
distintos tipos de datos, ilustremos el ejemplo en el prompt:
>>> valor_entero,cadena,numero_real=30,"Miguel Lopez",0.75
>>> valor_entero
30
>>> cadena
Pág. 24
'Miguel Lopez'
>>> numero_real
0.75
>>>
Intercambiar valores de una variable

En Python se pueden intercambiar el contenido de 2 variables, sin
emplear variables auxiliares, veamos un ejemplo:
nombres="mama papa hijo hermana abuela nieto"

>>> marcas="ferrari ford toyota mclaren chevrolet dogde renault
honda suzuki"
>>> marcas,nombres=nombres,marcas
>>> marcas
'mama papa hijo hermana abuela nieto'
>>> nombres
'ferrari ford toyota mclaren chevrolet dogde renault honda suzuki'
>>>
En la ilustración anterior asignamos a una variable llamada nombres

varios elementos de la familia en forma de cadena, y en una variable
llamada marcas le asignamos varios elementos asociados a marcas de
carros en forma de cadena, luego mediante asignación múltiple y
posicionamiento, asignamos el contenido de nombres a marcas y viceversa
sin perder el contenido de ninguna variable, y resaltando el hecho que no
hubo necesidad de emplear variables auxiliares.
Tipos de datos
En Python al igual que en otros lenguajes de Programación
contamos con diversos tipos de datos, entre los más usados tenemos:
Cadenas (str)
Enteros (int)
Pág. 25
Reales (float)
Booleanos(True, False)
También podemos ver el tipo de dato que tiene una variable, con la
función type, veamos un ejemplo en el prompt:
>>> a=5
>>> b="miguel"
>>> c=50.45
>>> type(c)
<class 'float'>
>>> type(b)
<class 'str'>
>>> type(a)
<class 'int'>
>>> d=True
>>> type(d)
<class 'bool'>
>>>
Inicialización de variables
Hace mención a la asignación previa de una variable con algún dato,
es frecuente por ejemplo que una variable que se emplee para contar de
uno en uno, se le asigne un valor inicial de cero, ejemplo contador=0,
también pudiera ser con una variable que guarde que acumule una
sumatoria, ejemplo acumulador=0. Además, vale destacar que, si una
variable no se inicializa y esta se invoca sin un valor previo o ajeno a un
proceso de cálculo o asignación, esta dará un error en tiempo de ejecución,
pero no de sintaxis, ya que Python es un lenguaje interpretado.
>>> contador=0
>>> acumulador=0
Pág. 26
Ejercicio 0001.
A continuación, vamos a mostrar el famoso ¡Hola mundo!, punto
de partida en casi que todos los lenguajes de programación, como leí
alguna vez, "…es una tradición entre programadores ".
…En lo consiguiente toda vez que se inicie un Ejercicio

se empleara el entorno de edición de Python 3.8.2 o
la Herramienta Thonny, para ambas es válido y
funciona todos los ejercicios aquí propuestos. En
ambos con la tecla F5 se invoca la ejecución del código.
Código en el editor:
Luego de pulsar la tecla F5 La salida se veria asi:

Pág. 27
Tambien podemos ejecutar el ejercicio siguiendo la siguiente ruta:
Así de sencillo y de forma tan ligera seria nuestro primer programa

escrito en Lenguaje de programación Python, desde el modo de edición.
En la consola interactiva el proceso fuera sido más simple veamos,

desde el promp:
Documentación del código fuente

Una de los aspectos fundamentales a la hora de programar es que
los bloques de código de cada función o módulos de algún programa deben
tener información a modo de comentarios acerca de la que realiza cada
rutina, o aquellas que se prestan para confusión, recuerda que en algunos
casos no solo programaras para ti mismo, también podrás hacerlo para los
demás o en colaboración o trabajo de algún proyecto en equipo, y los
demás aparte de ti deben saber que significa o que hace determinada
rutina sin necesidad de que se tenga que revisar el código línea por línea,
de allí radica la importancia de documentar en el mismo código fuente las
rutinas más importantes, también para beneficio propio cuando se detiene
algún proyecto y se retoma, basta con leer unas pocas líneas y saber qué
hace determinada rutina o modulo del programa, o en general cualquier
Pág. 28
scrip (código fuente) no importa si es extenso o corto, se recomienda

siempre documentar.
Manejo de errores en Python

Al igual que en otros lenguajes de Programación, en muchas
ocasiones se podrán cometer errores, bien sea dando instrucciones desde
la consola interactiva de Python o intentando ejecutar código fuente desde
un editor. Al escribir programas o algunas instrucciones en el Lenguaje
Python se pueden distinguir 4 tipos de errores, casi al igual que en otros
lenguajes, estos son:
Errores Sintácticos: se produce cuando transgredes o violas

alguna norma de la formalidad del lenguaje, bien sea haciendo una
asignación, una falta de paréntesis, usar una palabra reservada, entre
otros. Veamos un ejemplo:
En este ejemplo, se cometieron 4 violaciones a las reglas

gramaticales de Python, primero a la variable (a) se le intento hacer una
asignación de forma incorrecta, luego mandamos a mostrar la variable a,
sin embargo, a pesar que a no tiene ningún valor el error en esa línea hace
mención a que a la instrucción print va seguida de abrir y cerrar paréntesis
y dentro de esta los argumentos o variables a mostrar.
Luego se intenta leer una variable, pero se nos olvidó cerrar el
paréntesis del mensaje como argumento dentro de la función input, y
Pág. 29
finalmente el ultimo error de este ejemplo fue que intentamos asignar a

(a) una variable llamada for, for no se puede usar como identificador de
una variable ni función, es una palabra reservada del lenguaje.
Errores Semánticos: un programa puede estar sintácticamente

perfecto, puede tener lógica sus instrucciones y aun así generar un error,
por ejemplo, que los resultados que arroje el programa no estén dentro
del rango de resultados, esto sería un error semántico, de significado, se
requiere revisar el código con paciencia y evaluar donde radica el problema
Errores lógicos: el orden de nuestras instrucciones o flujo de

ejecución en el programa no son las correctas y posiblemente la
combinación de órdenes y de formalidades gramaticales no sean las
correctas. Nuestro programa puede ejecutarse, pero no hace ni responde
al planteamiento para el que fue desarrollado. Vale destacar, que cuando
el código es extenso puede resultar complicado y tedioso ubicar el error,
pero no imposible
Errores en tiempos de Ejecución: este se genera cuando

nuestro programa al estar ejecutándose, se interrumpe, esto por lo general
ocurre al ingresar un dato que no corresponde al valor que admite una
variable, también puede deberse a un proceso que intenta acceder a una
lista y este está fuera del rango, también al intentar ejecutar un proceso
que genera error cuando un valor no se encuentra en la lista, por ejemplo
al usar la función index. Igualmente, si mencionamos una variable que no
se ha inicializado previamente o que se le esta reasignando un valor dentro
de un cálculo que la involucra (variable) y este no contiene ningún valor,
también al hacer divisiones por cero, entre otros.
Errores comunes
Veamos algunos errores sintácticos y otros en tiempo de ejecución,
desde de la consola interactiva haremos la ilustración, es igual de aplicable
Pág. 30
en modo de edición, a continuación, su descripción e ilustración desde el

promp:
Uso de variables no identificadas

Python por ser dinámico admite que las variables se vayan
declarando en función de la necesidad y si vamos a leer un valor por
teclado no obliga a declarar su tipo, el asume en función de contenido que
se le asigne, pero si invocamos una variable o la empleamos en un proceso
y esta no existe o no esta inicializada en algún valor, se generara un error
en tiempo de ejecución, el error no se producirá por sintaxis, en caso de
que estemos en modo de edición, el programa empezara su traducción, el
error saldrá a flote cuando llegue a la línea que hace uso de la variable que
no existe. Esto para el Lenguaje no es un error de Sintaxis, si estuviésemos
en un Lenguaje Compilado el error se evidenciaría antes de la traducción
y compilación.
A continuación ilustraremos desde la consola interactiva un típico
ejemplo de lo que se menciona acá, vale recordar que cuando se menciona
la traducción es el proceso de ejecutar línea a línea el código fuente de
nuestro código o script :
Fijémonos que en este ejemplo hemos inicializado 2 variables a y b,

aunque Python es dinámico si el valor al que hacemos mención no existe
previamente, no se leyó un dato, o no tiene una asignación de algún tipo
Pág. 31
con antelación. Al momento de que el intérprete se encuentre con la línea

donde se invoca una variable que no existe, generara un error en tiempo
de ejecución.
En este caso el error es que la variable d no existe. Se inició a con
un valor de 20, b con un valor de 30, y luego escribimos que c= a+d, al
no existir d, justo en esa línea ocurrirá una interrupción, además el error
es fácilmente identificable, fue un error del tipo NameErrror, un error en
el nombre, d no existe, un detalle importante a pesar que en el error indica
que este se dio en la línea 2 (pyshell#2). Si volvemos a ejecutar una
instrucción haciendo mención correcta a la variable. Todo estará listo.
Dejar espacios al comienzo de instrucciones

Una de las características de Python es su sencillez pero como todo
lenguaje formal, también es bastante riguroso con su sintaxis, como debe
ser, vale recordar que Python asocia los espacios al comienzo de una línea
o bloque de código con la indentación (abrir una llave en otros lenguajes),
entonces no debemos dejar espacios al comienzo de una linea, de por si
cuando se requiere indentación el propio Python la genera sola y si
estamos con algo editor, este por lo general también la genera por defecto
cuando se requiere. Veamos un típico ejemplo de error de indentación no
requerida, con una ilustración desde la consola interactiva
Este error es bastante evidente, el tipo de error que nos generó es

de tipo SyntaxErrror: un error de sintaxis, mencionando una indentacion
no esperada. Aquí el error es en la línea donde digo que k= d+c, fíjense
que deje un espacio antes de escribir la letra k, el intérprete lo tomo como
una falsa indentación, aunque los espacios entre sumas y cómputos luego
de arrancar una primera línea, Python si las tolera, veamos:
Pág. 32
Se aprecia que al inicio de la instrucción no hay espacio, pero luego

de la igualdad si y entre el operador aritmético también, sin embargo, este
tipo de banalidades el Lenguaje las tolera
Uso de Tipos de Datos incompatibles

Una variable en Python puede almacenar cualquier valor, pero si
convertimos su tipo en plena lectura o estamos haciendo cálculos,
debemos usar los tipos de datos acorde a su compatibilidad, una cadena
admite que se multiplique, pero no admite que se le sume un valor bien
sea entero o real, menos que se le divida. Con los números sucede similar,
admite cálculos entre tipos enteros y reales, pero no admite por ejemplo
sumar un entero con un dato tipo cadena de texto. Ilustremos lo anterior
en el prompt:
Primero inicializamos 3 variables (a, b y c), a la primera le

asignamos un valor entero, a la segunda una cadena y a la tercera variable
un numero con decimal, luego le asignamos a una variable d una división,
que es aplicable y no genera error porque ambos datos son números, (a)
es entero y (c) es real, luego mostramos el resultado de la división.
Pág. 33
Posteriormente y aquí viene el error, a (d) quiero asignarle la suma de

(d+b), al presionar el enter se genera el error, es de de tipo TypeError,
indicando que no soporta la suma de un real con una cadena.
Dividir por cero

Es típico en algunos casos, que alguna variable tenga el valor de
cero y no se tomó la precaución de omitir la división, si la variable que
funge como divisor tiene el valor de cero, dará un error en tiempo de
ejecución si el que tiene el valor de cero es el dividendo, no generara un
error, veamos, con una ilustración desde el prompt
Listas fuera de rango

Si por ejemplo estamos manipulando listas o valores que contengan
un índice (listas, tuplas), y hacemos mención en alguna operación a un
índice que no esté comprendido en la lista o tupla, esta dará un error en
tiempo de ejecución
Pág. 34
En el anterior ejemplo declaramos una lista con varios nombres,

primero en el prompt mandamos a mostrar la lista nombres en la posición
cero, luego en la 2, pero cuando le decimos que muestre el nombre en la
posición 5, se genera el error, de tipo IndexError, fuera del rango. Vale
recordar que los índices en este lenguaje y en muchos otros empiezan en
la posición cero, y en la lista anterior marca hasta el índice 4.
Leer tipo de datos diferente al permitido

Toda lectura de variable empleando la función input lo tomara como
una cadena, excepto si indicamos lo contrario, en tal caso si al leer un dato
de tipo entero o real, ingresamos una cadena, el programa generara un
error en tiempo de ejecución, veamos una ilustración en el prompt
En este ejemplo el error se dio por ingresar una cadena en una

lectura de variable programada para recibir un valor de tipo entero
Pág. 35
Típico error en modo edición

En Python cuando se intenta ejecutar un programa y este genera
un error de sintaxis, en modo de edición, veremos algo así:
Si el error ocurre durante la ejecución veremos lo siguiente:
Siempre debemos estar pendiente del tipo de error que arroja, en

este caso arrojo un error de tipo ValueError:, igualmente en el mensaje
de error nos indica en que línea sucede el problema. En el mensaje
asociado a la expresión ValueError, para este caso nos está indicando que
Pág. 36
el signo / no pertenece a la base 10 de tipo entero En este momento ya

somos capaces de empezar a auto exigirnos ejercicios que requieran ir
poniéndole más empeño.
Existe un método en Python que nos permite capturar y
manejar los errores (en tiempo de ejecución) mediante el empleo
de la cláusula (Try Except), lo abordaremos en el capítulo II de
este texto, y así evitar que nuestros programas se aborten en
tiempos de ejecución.
Palabras reservadas y de uso Exclusivo de Python

Existen un conjunto de palabras que el Lenguaje de Programación
Python, se reserva para uso exclusivo de sus funciones o instrucciones de
algún método, dichas palabras no se pueden emplear para identificar
variables o métodos en Python. Estas son:
>>> import keyword

>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if',
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
'return', 'try', 'while', 'with', 'yield']
>>>
Todas las palabras entre comilla simple, son de uso exclusivo del
Lenguaje.
Ejercicio 0002.
Escribir un programa que permita sumar 2 Números y mostrar el
resultado
Para este ejercicio no se leerá ninguna variable por teclado,
simplemente procederemos por vía de asignación, le daremos un valor a
la variable que llamaremos (a) y otro valor a la variable que llamaremos
(b), seguidamente a una variable que denominaremos suma le
asignaremos el resultado de sumar lo que hay en (a) + lo que hay en (b).
Pág. 37
Luego procedemos por vía de mensaje en pantalla a mostrar el valor de la

variable (suma)
#Código en el editor:
a=50
b=30
suma=a+b
print(suma,"El resultado de sumar: ",a, " +", b)
Siempre al abordar un ejercicio debemos valorar algunos aspectos

tales como:
1. Las entradas de datos
2. Los Procesos requeridos
3. Salidas de información.
ES RELEVANTE DESTACAR: También se debe tomar en cuenta,

que si al abordar un problema de Programación, sentimos que no somos
capaces de entenderlo o plantear una posible solución, démonos un
descanso, salte a otro ejercicio o problema, intente descansar, comerse
algo, haga otra actividad que lo recree y relaje. Luego vuelva al rato y
abórdelo con calma, es un consejo que daría a cualquier persona que se
esté iniciando en Programación, e incluso a veteranos.
Ejercicio 0003.
Desarrollar un programa que permita sumar 2 números leídos por
teclado y mostrar el resultado
A diferencia del ejercicio anterior aquí si leeremos el valor de 2

números por teclado y luego mostraremos el resultado.
print("Ingrese el Valor 01 y valor 02")

valor1=input()
Pág. 38
valor2=input()
suma=int (valor1)+ int (valor2)
print("La suma de :"+valor1+"+"+ valor2+" es="+str(suma))
Ejercicio 0004.
Escribir un programa que permita leer nuestro nombre y saludarnos
minombre=input("Dime Tu Nombre:")
print("Hola, ",minombre, ", Bienvenido a Programando con Python")
Hasta los momentos hemos escrito 4 programas medianamente

sencillos, sin mayores exigencias, resaltando de lo anterior tenemos:
Asignar el valor a una variable=30

variable empleamos el signo igual variable= "Pedro Jose"
=
Mostrar un mensaje o print (variable)
variable empleamos la función print(" Un mensaje")
print
Leer un dato por teclado se variable=input ()
usa la función input
variable= int(input())
Leer un dato y convertirlo a
entero
Convertir datos a valores variable=int(variable)
enteros empleamos el método int
Importante: toda función atribuible al Lenguaje de Programación

Python es una palabra reservada del Lenguaje, en este existen varias
palabras reservadas, para no saturar, poco a poco iremos mencionando
las que se empleen en este texto. Es necesario resaltar que en Python cada
función o método, que también sería una función aplicable a un tipo de
Pág. 39
dato, se emplea mediante la invocación de una palabra reservada y se le

pasan uno o más argumentos para su uso.
¿Cómo se usa un método (función) propia del lenguaje

Python?
En Python existen muchas funciones, algunas las emplearemos acá,
no todas, pero si varias, por citar una de las más usadas print que sirve
para mostrar variables y mensajes. Esta función, para su uso debemos
indicarle que deseamos mostrar y para ello abrimos paréntesis si es un
mensaje colocamos comilla simple o doble, luego el mensaje, seguido del
cierre del paréntesis; si es solo una variable basta con colocar el nombre
de la variable sin colocarla en comillas, igualmente en una misma línea se
pueden concatenar varias etiquetas o cadenas y mostrar mensajes y
variables al mismo tiempo.
Algunas ilustraciones empleando la Función print:
Mostrando una variable print(variable)

Mostrando un mensaje print("un mensaje")
Mostrando un mensaje y print("Hola mi nombre es: "+
una variable de tipo cadena mi_nombre)
Mostrando un mensaje y print("Mi edad",edad)
una variable de tipo entero o real
Mostrando varias cadenas y print(mayor,"Es el mayor
varias variables de tipo entero o de",a," y de ",b)
real
La función input se emplea para leer datos, vale recordar que todo
lo que leemos en Python es una cadena a menos que indiquemos lo
contrario, el único argumento que le podemos pasar a input al menos en
este texto, será un mensaje al leer la variable con eso nos ahorraríamos
escribir un mensaje o una línea de código.
Pág. 40
Algunas ilustraciones empleando la Función input:

Leer una cadena y variable=input()
asignarla a una variable
Leer una cadena y variable=input("Dime tu
mostrar un mensaje como nombre")
argumento
Leer una cadena y mi_edad=int(input("Dime tu
convertirla a entero edad:"))
Leer una cadena y sueldo=float(input("Sueldo: "))
convertirla a real
En Python se emplean diversos tipos de operadores:

aritméticos, de comparación y lógicos, veamos los más
importantes:
Operador Tipo Aplicación

+ Aritmético Sumar
- Aritmético Restar
* Aritmético Multiplicar
/ Aritmético Dividir
> Comparación Mayor que (dato)
< Comparación Menor que (dato)
<= Comparación Menor o igual que (dato)
>= Comparación Mayor o igual que (dato)
== Comparación Un valor igual a otro valor
!= Comparación Un valor distinto a otro
valor
And Lógico Verificar si una condición se
cumple junto con otra
instrucción o más
instrucciones
Or Lógico Verificar si al menos una
condición se cumple
Not Lógico Verificar si una condición
no es verdad
Pág. 41
Continuaremos resolviendo otros ejercicios donde se ponga de

manifiesto el empleo de los operadores aritméticos así como las funciones
antes ilustradas, en muchos casos en la resolución de un ejercicio es
indudable que el enfoque matemático y lógico siempre estará presente,
muchos aspectos como obtener un promedio, sumar valores, plantear una
regla de 3 son aspectos que se consideran más allá de que haya que
llevarlos a lenguaje de programación, se asumen que los aspectos básicos
de estas operaciones se comprende, puesto que estos tipos de cálculos y
operaciones son cuestiones elementales que se vieron en bachillerato.
Ejercicio 0005.
Escribir un programa que permita obtener el promedio de las
calificaciones de un estudiante, considerar cuatro exámenes durante el
semestre, los cuales tienen la misma ponderación
Para abordar este problema debemos primero considerar el hecho

de que el norte es obtener un promedio, en la práctica este se obtiene
sumando los valores de varios elementos y luego dividimos ese resultado
entre el total de elementos sumados. Acá haremos lo mismo, los elementos
que se van a sumar son las notas de los exámenes y como el problema
indica que son 4, luego dividiremos por este número esa sumatoria. Ya
programando, inicialmente desplegamos un mensaje indicando que se
pedirán las 4 notas, se leen las 4 notas por teclado y se procede obtener
el promedio de estas y lo mostramos.
print ("Ingresar las 4 calificaciones")
a= float(input())
b= float(input())
c= float(input())
d= float(input())
pro=(a+b+c+d)/4
print(pro, "Es el Promedio de las 4 Calificaciones")
Pág. 42
Programación en escalera
A medida que se vaya puliendo, practicando cada vez más, intentara
resolver programas de mayor complejidad y requerimientos. Seguramente
aparte de los aquí propuestos y resueltos, desde aquí le sugiero, que vaya
programando como si estuviese ascendiendo en una escalera, poco a poco,
no ir de prisa, cada vez que vaya agregando nuevas instrucciones vaya
probando su código, de tal manera, si comete un error, podrá saber
aproximadamente donde ubicarlo y tal vez como solventarlo, ahorrando
tiempo, esfuerzo y desgaste mental que a la postre puede terminar
afectando su avance en programación o hacerle perder el ánimo. Esto en
palabras mayores se denomina control de versiones.
Además, si siente que puede cometer una imprudencia que ponga
en riesgo lo que lleva, guarde con otro nombre el código en el que está
experimentando, de tal manera, que lo que lleva bien no lo pierda o no
sufra para continuar hasta donde iba bien; lo anterior se recomienda en
caso de que lo nuevo que está probando no lo convenza o haya
entorpecido todo lo que llevaba bien.
Ejercicio 0006.
Escribir un programa que permita resolver lo siguiente: Un
productor de leche lleva el registro de lo que produce en litros, pero cuando
entrega le pagan en galones. Codifique la solución que ayude al productor
a saber cuánto recibirá por la entrega de su producción de un día (1 galón
= 3.785 litros).
En este problema tenemos 2 entradas, el número de litros de leche

y el precio por galón. Conociendo de antemano que un galón equivale a
3.785 litros, en el proceso dividimos el número de litros que se produjo en
el día entre el valor de un galón en litros (3.785) y ese resultado lo
multiplicamos por el costo que se cancela por galón y así obtendríamos la
paga que recibirá el productor.
Pág. 43
galon=3.785
print ("Ingrese N° de Litros de Producción de leche: ")
litros= float(input())
print ("Ingrese el Monto de la paga por Galón: ")
valor_pago= float(input())
conversion_litros=litros/galon
pago_de_leche=conversion_litros*valor_pago
print(pago_de_leche, "Es el Monto a Obtener por la producción de:
",litros, "litros de leche")
print(conversion_litros,": Serian el total de galones")
Es Relevante Destacar: se aconseja ejecutar varias veces

los programas con diferentes datos, de tal manera que los
resultados estén en el rango de la lógica del planteamiento a
resolver
Definición de una función, construcción e invocación

La programación ha evolucionado, con ella su estilo, hay que estar
a la vanguardia, hoy por hoy, buena parte de los lenguajes están
orientados a objetos, y esto conlleva manejar o distinguir acerca de clases,
métodos, atributos, objetos de una clase, funciones, recursividad. Aunque
más adelante tocaremos algunos aspectos, no me adelantare tanto. Este
punto lo comentaba, porque en Programación la automatización de
algunas rutinas, y reuso de código pasa por el hecho de construir nuestras
propias funciones que nos permitan tener un código más impecable, más
reutilizable y orientado a una Programación un poco más Profesional.
Si es bien es cierto que, a nivel de Latinoamérica, citando países
como Colombia, México, Venezuela, la enseñanza y resolución de
algoritmos y codificación por lo general se enfoca en el siguiente patrón:
manejo de estructuras secuenciales, condicionales, bucles, arreglos,
funciones y procedimientos. Digamos que muchas veces ese ha sido el
estándar de enseñanza de un Lenguaje de Programación, y recordando
que cualquier lenguaje por muy potente que pueda ser, primero se debe
Pág. 44
estudiar desde cero y luego se avanza, igual recomendación para cualquier

otra persona, así se considere experto programando o tenga experiencia.
Acá no seguiremos este estándar, ya en las próximas líneas
empezaremos a usar y construir nuestras propias funciones y
procedimientos, y a medida que se avance y se vaya conociendo el
lenguaje se le irán incorporando los otros elementos del patrón que
comente en líneas anteriores, sin embargo, tampoco nos quedaremos con
eso. Python permite desarrollar soluciones muy poderosas, pero debemos
conocer el lenguaje, y este texto ha sido concebido para ello y para la
resolución de problemas desde cero.
La cláusula return
Cada vez que nuestros programas se encuentren con la función
return, el flujo de ejecución abandonara inmediatamente la función donde
esta se encuentre, volverá al punto donde se invocó, sino existiese más
flujo de ejecución, nuestro programa finalizara, esto ocurre aun existiendo
más instrucciones por ejecutar dentro de la función. Además, la función
return permite devolver valores al punto de invocación de una función,
otro de los usos de esta cláusula es verificar funciones y abortarlas para
comprobar errores.
Nuestra Primera Función hecha en Python

Lo primero que debemos saber, es que para definir una función en
este lenguaje se empieza por escribir la Palabra reservada def
seguidamente del nombre de la función, luego abre y se cierra paréntesis
y finaliza en dos puntos. Y como todo en Python, todo el bloque de la
función lleva indentación y a su vez cada lote de instrucciones en cada
bloque. Veamos un ejemplo:
Ejercicio 0007.
Desarrollar un Programa que permita calcular la edad de una
persona, dado su fecha de nacimiento
#Función para calcular la edad de una persona
Pág. 45
def calcular_edad(fecha_nac,ano_actual):
edad=ano_actual-fecha_nac
return edad
print(calcular_edad(1985,2020), "Años de Edad tiene la persona")
Expliquemos el asunto, empezamos por definir la función, esta

puede tener uno, nada o muchos argumentos, la misma cantidad de
argumentos que se indican al invocarse, debe tener también en su
definición, sin embargo, Python es tan peculiar que hasta en esto rompe
los esquemas, Python permite que estas reglas no necesariamente sean
así, pero para nosotros seguirá siendo y también para este texto.
Cuando hacemos el llamado de la función nótese, que este se

encuentra como argumento dentro de una función del lenguaje Python
print, y como toda función se le pueden pasar argumentos, aquí le
estamos diciendo señora print aquí le dejo esta función, llámela o
invóquela, envíele el año en que nací y el año actual, y de allá nos va
mandar un resultado, ese valor muéstrelo, seguido de la cadena "Años de
Edad tiene la persona". Esto es lo que acaba de Ocurrir.
Por supuesto al llamar una función podemos pasarle como

parámetro o argumento variables leídas por teclado, asignaciones
previamente hechas y cualquier otro valor que se requiera, también como
lo mencione anteriormente una función no necesariamente lleva
argumentos y tampoco para su llamada requiere que este como argumento
de una función de Python.
El valor agregado de una función aparte de que permite reusar

código es que esta puede ser invocada todas las veces que sea necesario,
una función no siempre retornara un valor, puede que no retorne nada,
eso depende de lo que programemos, también en Python se permite el
Pág. 46
retorno de varios valores o variables y está a su a vez asignárselos a otras

variables.
Importantísimo: las variables y operaciones que se ejecuten en
una función solo sirven y existen allí, salvo que recuperemos algún
resultado o valor mediante el retorno y este a su vez asignárselo a una
variable global.
A continuación, calcularemos el Mayor de 3 Números, primero

lo haremos, pasando los números a comparar como argumentos luego se
hará leyéndose dentro de la función y que esta nos retorne el mayor y
también los números que se sometieron al cálculo, algunos planteamientos
a veces observaremos que no dicen mostrar, y debemos asumir que si
vamos a calcular un valor, lo lógico sería mostrarlo y de esta forma también
se mide la efectividad de la solución, salvo en aquellos casos, donde la
naturaleza del procedimiento no lo amerite o que el mismo enunciado así
lo indique, veamos cómo queda:
Ejercicio 0008.
Calcular y mostrar el mayor de 3 Números
#Código en el editor
def calcular_mayor(a,b,c):
mayor=a
if b> mayor:
mayor=b
if c> mayor:
mayor=c
return mayor
print(calcular_mayor(6,9,15),"Es el Mayor de 6 - 9 - y 15")

Pág. 47
Ejercicio 0009.
Veamos la segunda forma y aquí agregaremos otra nueva función
de Python str, la cual permite convertir en cadena un valor:
def calcular_mayor():
a=int(input("Indique el valor a: "))
b=int(input("Indique el valor b: "))
c=int(input("Indique el valor c: "))
mayor=a
if b> mayor:
mayor=b
if c> mayor:
mayor=c
return a,b,c,mayor
x1,x2,x3,may=calcular_mayor()
print(may, "Es el Mayor de "+str(x1)+ ","+str(x2)+" ,"+str(x3))
ejecutando el ejercicio e Ingresando los valores de 30 , 15 y 80:,

la salida seria así:
Indique el valor a: 30
Indique el valor b: 15
Indique el valor c: 80
80 Es el Mayor de 30, 15, 80
>>>
Poco a poco hemos ido incrementando el Nivel de complejidad y así

continuaremos y también ir conociendo las demás funciones de Python y
aplicabilidad, observemos que en los dos ejercicios anteriores empezamos
Pág. 48
a usar operadores de comparación y la construcción de nuestra primera

función y nuestra primera decisión, cuando lo amerite vamos a
explicar con detenimiento, varios aspectos aquí presentes y otros nuevos
que emplearemos en lo sucesivo.
Condiciones / Estructuras Selectivas

En Python para establecer una condición, se emplea el método if,
una condición con caso contrario if else y varias condiciones anidadas con
caso contrario seria if elif else, cada bloque respeta su indentacion,
ilustrando esta explicación:
Una condición simple if

if nota>=10:
print("Aprobado")
Una condición doble: if else

if nota>=10:
print("Aprobado")
else:
print(("Reprobado")
Una condición anidada if elif else
if nota>15:
print("Sobresaliente")
elif nota >=10:
print("Aprobado")
else:
print("Reprobado")
Ya hemos escrito varios programas y poco a poco estamos

exigiéndonos más, de los últimos ejercicios y aspectos podemos resaltar lo
siguiente
Pág. 49
La Función str convierte un Valor=str(20)

valor en cadena
Toda definición de función def mifuncion():
empieza por la palabra reservada def
y finaliza en dos puntos
Toda condición inicia con la if 5>9:
palabra reservada if y finaliza la línea
en dos puntos:
Condición con caso contrario if 3<5:
if else ambos finalizan en dos print(‘menor’
puntos else:
print(‘mayor’)
Condición anidada if elif else if edad>20:
todas finalizan en dos puntos: y el print('Adulto')
bloque de código de cada una lleva elif edad<=12:
indentacion print("Niño")
else:
print("Adolescente")
A continuación, se desarrollarán varios ejercicios donde pondremos

de manifiesto todo lo visto hasta aquí, luego empezaremos con otras
funciones y así paulatinamente, con nuevas funciones, se explicarán y se
indicara su correspondiente sintaxis y argumentos que toman para poder
ejecutarse.
Ejercicio 0010.
Realizar un Programa para determinar la nota final que obtendrá un
alumno considerando que realiza tres exámenes, de los cuales el primero
y el segundo tienen una ponderación de 25%, mientras que el tercero de
50%.
Pág. 50
#Definición de función principal pedido y cálculo de notas

def calculo_notafinal(p1,p2,p3):
print("Indicar por favor las 3 Notas")
n1=input()
n2=input()
n3=input()
nota_final=float (n1)*p1+float(n2)*p2+float(n3)*p3
#Luego de calcular la Nota final, le aplicamos el Método round

#El cual permite redondear un valor y en este caso a 2 decimales
nota_final=round(nota_final,2)
#return permite devolver un valor o varios valores

#al punto de invocación o llamado de la función
return nota_final
#Declaracion de Porcentajes de Parciales

p1=0.25
p2=0.25
p3=0.50
"""Invocación a función pasándole como argumentos los

porcentajes
de cada parcial:
...Y a print le pasamos como argumento el llamado la función que

se
encargará de pedir y calcular la nota final, de esta manera muestra
el valor que retorna luego de ejecutarse dicha función """
print(calculo_notafinal(p1,p2,p3),": NOTA FINAL ALUMNO")

Pág. 51
Para la solución del ejercicio anterior nos hemos auxiliado con una
función en la parte principal, además hemos utilizado la función print y a
esta le hemos pasado como parámetro nuestra función principal que lee
los datos, hace los cálculos y retorna el valor, al emplear la función print
en medio del llamado nos aseguramos que el valor que retorne se muestre
junto con los demás argumentos indicados en el print.
Antes de la invocación de nuestra función principal, hemos

declarado el valor porcentual de cada evaluación, aquí hago un
paréntesis, para resaltar lo siguiente: muchas veces nos piden calcular
porcentajes, aumentos, en diferentes problemas, ¿Cóm o se debe
form ular los cálculos de un porcentaje? , aquí y en todos los ejercicios
propuestos y resueltos, voto por trabajar con índices estadísticos.
Pero, ¿cómo es eso?, sencillo si nos dicen 30% es igual a 0.3, si no

hablan de 7% es igual a 0.07, cualquier porcentaje que nos digan lo
tomamos y mentalmente lo dividimos entre 100 y eso nos arrojara un valor
en índice estadístico comprendido entre 0 y 1. Si nos piden determinar el
nuevo sueldo de un trabajador, dado un aumento del 30%, lo haríamos
asi; sueldonuevo=sueldoviejo*1.30 o también podría ser así,
nuevosueldo=sueldoviejo+(sueldoviejo*0.3) , también seria valido
nuevosueldo=sueldoviejo*(1+0.3), por cualquiera de las 3 formas
calculamos este valor. En este sencillo ejemplo el 1 equivale a decir 100%
y en un cálculo de aumento siempre debemos calcular la fracción de
aumento y sumársela al monto original.
Es típico, que al calcular un monto donde nos piden % de aumento

solo se calcule el aumento y no se sume al monto original, o que nos piden
un descuento y calculemos la fracción pero no restamos el resultado al
monto o valor original, debemos tener cuidado al trabajar con porcentajes,
una forma correcta seria sustituir por valores en nuestras formulas
empleadas y verificar si los resultados obtenidos están en los rangos que
corresponden; si en el ejemplo del párrafo anterior por el contrario nos
Pág. 52
pidieran determinar el nuevosueldo dado un % descuento, seria así:

nuevosueldo=sueldoviejo-(sueldoviejo*0.3).
Continuando con la explicación del ejercicio, al hacer el

llamado de nuestra función calculo_notafinal le hemos pasado como
parámetro los valores porcentuales que corresponden a cada evaluación,
luego en la ejecución de esta lo primero que hicimos fue leer las 3 notas
en forma de cadena y luego al hacer al cálculo cada variable la convertimos
a un dato de tipo real, en la fórmula empleada se multiplica cada valor
porcentual por cada nota de la evaluación y esos productos parciales se
suman y se obtiene la nota final, luego mediante el empleo de la función
return nos devuelve el valor desde donde invocamos la llamada, la función
return lo único que hace es devolver valor o valores, todo depende de lo
que instruyamos en la programación, vale recordar que una función puede
o no retornar un valor, eso depende de lo que desarrollemos.
Pase de argumentos y recepción de argumentos

Cuando se llama a una función y le pasamos un dato o varios datos,
una variable o varias variables, la función que se va a ejecutar debe recibir
y hacer declaración de la misma cantidad de variables que se reciben en
su invocación de lo contrario generara un error en el pase de estos
argumentos:
Sería correcto
def recepcion(v1,v2,v3) #declara 3 variables, mismo orden que
reciba
-----------
-----------
-----------
recepcion(3,5,9) # envía 3 valores o variables según sea el caso
Sería incorrecto
def recepción(v1,v2) # Declara recibir 2 argumentos

Pág. 53
-----
-----
recepción(4,6,9) # Envia 3 argumentos
Ejercicio 0011.
Efectuar un programa para determinar aproximadamente cuántos
meses, semanas, días y horas ha vivido una persona, dado la edad de esta.
def tiempo_devida(fn,actual):
edad=actual-fn
meses=edad*12
semanas=edad*52
dias=edad*365
horas=dias*24
return edad,meses,semanas,dias,horas
fn=int (input("Ingrese Año Nacimiento:"))

actual= int (input("Año Actual"))
ed,mes,sem,dia,hs=tiempo_devida(fn,actual)
print("Edad Meses Semanas Dias Horas")
print(ed,mes,sem,dia,hs)
En el anterior ejercicio hemos resuelto un sencillo problema

tomando como referencia unos valores aproximados, mas no exactos ni
tomando en cuenta años bisiesto, ni cálculo exacto de los meses que
terminan en 30 o 31 días.
Si sabemos la edad de una persona podemos saber cuántos meses
de vida tiene, sencillo multiplicamos la edad expresada en años por 12,
para saber las semanas multiplicamos la edad por 52, este valor se obtiene
de dividir 365 /7 y tomando la parte entera obtendríamos el 52. Para los
días la edad multiplicada por 365 que sería el total de días aproximado de
Pág. 54
un año, y teniendo los días multiplicamos ese dato por 24 y obtendríamos

las horas, un día trae 24 horas.
Ejercicio 0012.
Escribir un programa para determinar si un número es positivo o
negativo.
numero=int(input("Indicar Numero:"))
if numero>0:
print("Numero es Positivo")
else:
print("Numero es Negativo")
Bastante sencillo este ejercicio finalizado, solo comprueba si un

Numero es positivo o Negativo y nos indica esa comprobación con un
mensaje, recordemos que un Numero es Negativo si es menor a cero (0).
Ejercicio 0013.
Realizar un programa para determinar cuánto se debe pagar por
equis cantidad de lápices considerando que si son 1000 o más el costo es
de 85; de lo contrario, el precio es de 90.
def calculo_pago(cantidad):
if cantidad>=1000:
costo=85
else:
costo=90
pago=costo*cantidad
return pago
cantidad=int(input("Indicar Cantidad de Lapices:"))

Pág. 55
print(calculo_pago(cantidad), " : MONTO FINAL A PAGAR")
Desarrollando este ejercicio nos topamos con una instrucción de

comparación, la cual decidirá el costo de cada lápiz en función de la
cantidad a comprar de estos. Para ello primero definimos una función
calculo_pago la cual recibe como argumento el número de lápices a
comprar luego empieza la comparación primero evaluando si esa cantidad
es mayor o igual a 1000 si no es el caso por defecto aplicara el segundo
criterio con las instrucciones que se encuentran dentro del else. En las
únicas dos líneas de nuestro programa principal en la primera pedimos el
número de lápices, esta se pasa como argumento al llamar a la función
que hace los cálculos y esta se encuentra como argumento igualmente en
la función print, que luego del retorno se visualizara el resultado que
devolvió la función seguida del mensaje que acompaña el dato.
¿Acaso existe una única forma de Programar o resolver un

problema mediante el uso de la Programación?
La Respuesta es una sola NO. Por lo general una posible solución se
puede abordar de diversas formas, sin embargo un principio a seguir,
debería ser, la solución que se genere no debe ser redundante o ambigua
y debe tener un numero proporcional de líneas de código con respecto al
planteamiento, otro factor a considerar es que no es igual sumar dos
números en un lenguaje interpretado a sumarlo en un lenguaje estático,
en el segundo se requerirá un número mayor de líneas aunque el código
salvando la sintaxis debería ser casi igual, la lógica de programación.
Un caso m uy típico es cuando calculam os el m ayor de 3
núm eros , mi persona lo resuelve partiendo del hecho que el mayor es el
primer valor y luego con dos condiciones independientes evaluó si alguno
de los otros dos valores es mayor y sustituyo el valor de la variable mayor,
he visto casos donde la persona efectúa comparaciones anidadas
empezando por el primer valor comparándolo con el segundo y tercero y
luego aplica lo mismo al segundo valor y finalmente por defecto asume
que es el tercero.
Pág. 56
También he observado que se calcula el mayor entre dos valores y

luego se compara con el tercer valor y por ultimo he visto intentos fallidos
que no dan con la solución. Sin embargo, en este ejemplo que ilustro, sigo
defendiendo la forma como resuelvo el mayor de 3, código ultra eficiente,
efectivo, minimiza el error y llega concretamente a lo que se pide; vale
agregar que de las 3 formas se soluciona el problema, a continuación, el
código de las tres formas:
#Versión 01
a=int(input("Valor de A: "))
b=int(input("Valor de B: "))
c=int(input("Valor de C: "))
mayor=a
if b > mayor:
mayor=b
if c > mayor:
mayor=c
print(mayor," es el Mayor de los 3 Números")
#Versión 02
if a > b and a>c:

mayor=a
elif b > c and b >a:
mayor=b
else:
mayor=c
Pág. 57
#Versión 03
if a > b:
mayor=a
else:
mayor=b
if c > mayor:
mayor=c
Ejercicio 0014.
Una empresa dedicada a ofrecer banquetes; sus tarifas son las
siguientes: el costo de platillo por persona es de $95.00, pero si el número
de personas es mayor a 200 pero menor o igual a 300, el costo es de
$85.00. Para más de 300 personas el costo por platillo es de $75.00. Se
requiere un Programa que genere el presupuesto que se debe presentar a
los clientes que deseen realizar un evento.
def entradas():
personas=int(input("Numero de Personas para el Evento:?"))
if personas>300:
costo_platillo=75
elif personas>200 and personas <=300:
costo_platillo=85
Pág. 58
else:
costo_platillo=95
return personas, costo_platillo
def generar_presupuesto():
a,b=entradas()
presupuesto=a*b
presupuesto=round(presupuesto,2)
print(presupuesto,": Costo del Evento para :",a," Personas")
generar_presupuesto()
Ejercicio 0015.
La asociación de vinicultores tiene como política fijar un precio inicial
al kilo de uva, la cual se clasifica en tipos A y B, y además en tamaños 1
y 2. Cuando se realiza la venta del producto, ésta es de un solo tipo y
tamaño, se requiere determinar cuánto recibirá un productor por la uva
que entrega en un embarque, considerando lo siguiente: si es de tipo A,
se le cargan 20$ al precio inicial cuando es de tamaño 1; y 30$ si es de
tamaño 2. Si es de tipo B, se rebajan 30$ cuando es de tamaño 1, y 50$
cuando es de tamaño 2. Realice un Programa determinar la ganancia
obtenida y la perdida.
Primeramente, debemos leer pausadamente el enunciado para así

determinar cuáles son nuestros datos de entrada, procesos y finalmente
obtener la ganancia o pérdida, tal como plantea el problema. Debemos
pedir el precio por kilo de uva el cual será el mismo para cualquier tipo de
uva y tamaño, los otros dos datos de entrada serán tipo de uva y tamaño.
Con estos datos empezaremos a desglosar el proceso o procesos para
solucionar nuestro problema. Estableceremos condiciones para resolver el
Pág. 59
hecho que dependiendo del tamaño y tipo se le suma o resta determinado

monto al precio del kilogramo de uva, a continuación, la solución.
def tamano_tipo():
def calcular_pago(kilos,precio,tipo,tam):
if tipo ==1:
if tam==1:
precio=precio+20
else:
precio=precio+30
else:
if tam==1:
precio=precio-30
else:
precio=precio-50
pago=precio*kilos
return pago
kilos=float(input("Cuantos Kilos de Uva son:"))

precio=float(input("Costo del Kilo de Uva:"))
tipo=int(input("Indique el tipo de UVA 1(A) 2(B): "))
tam=int(input("Indique el Tamaño 1 / 2: "))
print(calcular_pago(kilos,precio,tipo,tam),": Monto a Cobrar el
Productor")
tamano_tipo()
Ejercicio 0016.
Desarrollar programa que resuelva lo siguiente: Se requiere
determinar cuánto se le debe cobrar a cada alumno por el servicio de un
Pág. 60
viaje en autobús. La forma de cobrar es la siguiente: si son 100 alumnos

o más, el costo por cada alumno es de $65.00; de 50 a 99 alumnos, el
costo es de $70.00, de 30 a 49, de $95.00, y si son menos de 30, el costo
de la renta del autobús es de $4000.00, sin importar el número de
alumnos.
Teniendo el número de alumnos empezamos a evaluar como

procederemos:
Si numero_alumnos mayor o igual a 100
Costo = 65
Caso contrario
Si numero_alumnos esta comprendido entre 50 a 99
Costo= 70
Caso contrario
Si numero_alumnos está comprendido entre 30 a 49
Costo= 95
Sino
Costo=4000 lo dividimos entre el Numero_alumnos
def viaje_alumno():
costo=0
n_alumnos=int(input("N° de Alumnos para el Viaje:"))
if n_alumnos>=100:
costo=65
elif n_alumnos>=50 and n_alumnos <=99:
costo=70
elif n_alumnos>=30 and n_alumnos<=49:
costo=95
else:
costo=4000/n_alumnos
pago=4000
Pág. 61
pago=costo*n_alumnos
pago=round(pago,2)
return costo,pago
def mostrar_salidas():
xreturn,yreturn=viaje_alumno()
print(xreturn,"Costo por Alumno del Viaje")
print("Costo Total del Viaje: ",yreturn)
mostrar_salidas()
Uso de la función round

Este método aplicable a resultados o variables que contienen datos
con fracciones decimales, permite obtener la parte entera de un número,
y también permite obtener la parte entera y una cantidad determinada de
decimales según lo que le indiquemos en sus argumentos veamos:
a=33.333333333
a=round(a)
Para este ejemplo el nuevo valor de a seria= 33,
Si decimos a=33.3333333
a=round(a,2)
a=33.33 este sería el Nuevo valor de round, tomando la parte
entera y solo dos decimales
Ejercicio 0017.
Un centro de Comunicaciones, el cobro es por el tiempo que dura la
llamada, de tal forma que los primeros cinco minutos cuestan $ 1.00 c/u,
los siguientes tres, 80$ c/u, los siguientes dos minutos, 70$ c/u, y a partir
del décimo minuto, 50$ c/u.
Además, se carga un impuesto de 3 % cuando es domingo, y si es
día hábil, en turno matutino, 15 %, y en turno vespertino, 10 %. Realice
Pág. 62
un Programa para determinar cuánto debe pagar por cada concepto una
persona que realiza una llamada.
Nuestras entradas para el problema serán, día de la semana,

duración de la llamada y turno. El planteamiento nos indica que en base a
los minutos es el cobro, debemos considerar además que existe tarifa
plana es a partir del minuto 10, y los primeros 9 minutos varían de precios
en función de las condiciones que impone el problema. Con estas
consideraciones abordaremos nuestro problema, sin olvidar que luego de
calculado el costo de los minutos se agrega un impuesto en base a lo
planteado.
dias="1 2 3 4 5 6 7"
dias_habiles="1 2 3 4 5 6"
turnos="1 2"
def datos_llamada_impuesto():
def calcular_impuesto():
if dia in dias:
if dia in dias_habiles:
if turno in turnos:
if turno=="1":
impuesto=0.15
else:
impuesto=0.10
else:
impuesto=0.03
return impuesto
duracion=int(input("Duracion de llamada: "))

Pág. 63
dia=input("1. Lunes 2. Martes 3.Miercoles 4. Jueves. 5.Viernes. 6.

Sabado. 7.Domingo:\n")
turno=input("Turno Llamada 1. Matutina 2. Vespertino: ")
impuesto=calcular_impuesto()
return impuesto, duracion
def cobro(impuesto,tiempo):
p5=0
s3=0
s2=0
diferencia=0
if tiempo>10:
p5=5
s3=240
s2=140
diferencia=(tiempo-10)*50
elif tiempo >8 and tiempo <=10:
p5=5
s3=240
elif tiempo>5 and tiempo >=8:
p5=5
else:
p5=tiempo*1
pago=(p5+s3+s2+diferencia)*(1+impuesto)
pago=round(pago,2)
return pago
impuesto,tiempo=datos_llamada_impuesto()
print(cobro(impuesto,tiempo)," :Monto a CANCELAR POR LLAMADA")
Pág. 64
Función in, aplicabilidad

Esta poderosa función de Python, permite verificar si un elemento
lo contiene otro, si escribimos miguel y le decimos a Python que, si la letra
m se encuentra en miguel, esta debería arrojar un resultado verdadero y
así como este sencillo ejemplo aplica en lo demás, simplifica el acto de
busca o verificar si un elemento se encuentra en otro elemento, de una
forma muy sencilla. En el ejercicio anterior (ejercicio 0017), empleamos la
función in de varias formas y aquí a continuación observaremos un ejemplo
ilustrado de esta:
>>> a="m" in "miguel"

>>> a
True
Acabamos de escribir en el prompt, asígnele a la variable a el valor
que resulta de consultar si la letra m se encuentra en la cadena miguel, y
aquí (a) solo puede almacenar dos valores verdadero o falso, en el Capítulo
II de este Texto, abordaremos de forma detallada el uso aplicabilidad de
variables y operadores boleanos.
#Otro ejemplo
>>> nombres="miguel pedro jose maria valentina andrea".split()
>>> nombres
['miguel', 'pedro', 'jose', 'maria', 'valentina', 'andrea']
>>> buscar="miguel"
>>> resultado= buscar in nombres
>>> resultado
True
>>>
Ejercicio 0018.
Desarrollar un Programa para lo siguiente: Una compañía de viajes
cuenta con tres tipos de autobuses (A, B y C), cada uno tiene un precio
Pág. 65
por kilómetro recorrido por persona, los costos respectivos son $2.0, $2.5
y $3.0. Se requiere determinar el costo total y por persona del viaje
considerando que cuando éste se presupuesta debe haber un mínimo de
20 personas, de lo contrario el cobro se realiza con base en este número
límite.
Para considerar resolver este problema partimos del hecho de que

el viaje a realizar cuenta con tres opciones de autobuses y que
dependiendo de este es el costo por kilómetro, igualmente debemos
considerar que, si el número de viajeros es menor a 20 personas, este se
cobra como si fuese mínimo para este número.
def ingreso_datos():
tipo=int(input("Tipo de Autobus: 1. A 2. B 3. C: "))
personas= int(input("N° de Personas: "))
km= int(input("Km a viajar: "))
return tipo,personas,km
def calculo_pago(tipo,personas,km):
if tipo==1:
precio_km=2.0
elif tipo==2:
precio_km=2.5
else:
precio_km=3.0
if personas>=20:
cobro_viaje=km*precio_km*personas
cobro_individual=cobro_viaje/personas
else:
cobro_viaje=km*precio_km*20
cobro_individual=cobro_viaje/personas
Pág. 66
cobro_individual=round(cobro_individual,2)
return cobro_viaje, cobro_individual
tipo,personas,km=ingreso_datos()
cv,ci=calculo_pago(tipo,personas,km)
print(cv," :Costo total del Viaje ")
print("Costo Individual por Persona: ", ci)
Ejercicio 0019.
El consultorio de un Médico, tiene como política cobrar la consulta
con base en el número de cita, de la siguiente forma:
Las tres primeras citas a $200.00 c/u.
Las siguientes dos citas a $150.00 c/u.
Las tres siguientes citas a $100.00 c/u.
Las restantes a $50.00 c/u, mientras dure el tratamiento.
Se requiere realizar un Programa para determinar:

- Cuánto pagará el paciente por la cita.
- El monto de lo que ha pagado el paciente por el
tratamiento.
Como comenté hace varios ejercicios, un enunciado debe leerse con

calma, de tal manera de no apurar la solución y que esta no responda al
planteamiento como tal. Cuando un enunciado es medianamente largo o
existen varias consideraciones en su enunciado, debe abordarse su análisis
con calma.
Las primeras 8 consultas varían de precio y se debe estar pendiente
en la programación que esta se adecue a lo que se pide, luego de la cita 8
todas valen lo mismo, a la final el costo del tratamiento será la sumatoria
de lo acumulado según el número de consulta de esta.
Pág. 67
def cobro_consulta(n_consulta):
if n_consulta>8:
valor=50
tratamiento=1200+((n_consulta-8)*valor)
elif n_consulta>5 and n_consulta<=8:
valor=100
elif n_consulta>3 and n_consulta<=5:
valor=150
else:
valor=200
tratamiento=n_consulta*valor
return valor,tratamiento
n_consulta=int (input("N° Consulta Paciente: "))
valor,costo_tratamiento=cobro_consulta(n_consulta)
print("\n",valor,": Costo de Consulta\n")
print("Costo Acumulado de Tratamiento:",costo_tratamiento)
Ejercicio 0020.
Resolver con un programa: Una Fabrica produce artículos con claves
(1, 2, 3, 4, 5 y 6). Se requiere calcular los precios de venta, para esto hay
que considerar lo siguiente:
Costo de producción = materia prima + mano de obra + gastos de
fabricación.
Precio de venta = costo de producción + 45 % de costo de
producción.
Pág. 68
El costo de la mano de obra se obtiene de la siguiente forma: para

los productos con clave 3 o 4 se carga 75 % del costo de la materia prima;
para los que tienen clave 1 y 5 se carga 80 %, y para los que tienen clave
2 o 6, 85 %.
Para calcular el gasto de fabricación se considera que, si el artículo
que se va a producir tiene claves 2 o 5, este gasto representa 30 % sobre
el costo de la materia prima; si las claves son 3 o 6, representa 35 %; si
las claves son 1 o 4, representa 28 %. La materia prima tiene el mismo
costo para cualquier clave.
Este planteamiento tiene varias condiciones, las cuales tienen que

evaluarse con precaución para que la solución responda al enunciado
propuesto. Para ello he planteado dos funciones, en una función llamada
datos_entrada pediremos los datos necesarios para resolver el
problema, estos datos son el tipo de clave y costo de la materia prima.
Cuando invocamos esta función el resultado se lo asignaremos a dos
variables las cuales después pasan como argumento en la invocación de la
la función calcular_precio_venta, dentro de esta función se efectúan
los diversos cálculos asociados al planteamiento y debemos recordar que
en la invocación de nuestra anterior función esta se pasó como argumento
en la función print, esto se traduce en el hecho que una vez retorne el
valor de invocación esta mostrara el resultado, en este caso el precio de
venta del producto.
#Codigo en el editor
def calcular_precio_venta(clave,materia_prima):
#Calculo costo mano de Obra
if clave==3 or clave==4:
costo_mano_obra=materia_prima*0.75
elif clave==1 or clave==5:
else:
#Calculo costo Fabricacion
Pág. 69
if clave==2 or clave==5:
costo_fabricacion=materia_prima*0.30
elif clave==3 or clave==6:
else:
#Calculo costo Producción
costo_produccion=materia_prima+costo_mano_obra+costo_fabricaci
on
precio_venta=costo_produccion*1.45
return precio_venta
def datos_entrada():
clave=int(input("Indicar Clave:\n"))
materia_prima=int(input("Costo de Materia Prima:"))
return clave, materia_prima
clave,materia_prima=datos_entrada()
print(calcular_precio_venta(clave, materia_prima)," :Precio de
Venta")
Recursividad
En Programación se denomina recursividad al hecho de que una
función se pueda llamar así misma, esto es perfectamente válido y se debe
tener sumo cuidado al efectuarse para que los resultados y el
comportamiento de esta recursividad cumpla su propósito, por lo general
suele aplicarse en situaciones que requieren validaciones, sin incluir este
procedimiento en ningún bucle, a continuación, veremos un ejercicio
donde se pone de manifiesto el uso de la recursividad.
Pág. 70
Ejercicio 0021.
Una compañía de paquetería internacional tiene servicio en algunos
países de América del Norte, América Central, América del Sur, Europa y
Asia. El costo por el servicio de paquetería se basa en el peso del paquete
y la zona a la que va dirigido. Parte de su política implica que los paquetes
con un peso superior a5 kg no son transportados, esto por cuestiones de
logística y de seguridad. Realice un programa para determinar el cobro por
la entrega de un paquete o, en su caso, el rechazo de la entrega. Regirse
por la siguiente tabla
Zona Ubicación Costo/gramo
Zona Ubicación Costo/gramo
1 América del $11.00

Norte
2 América Central $10.00
3 América del Sur $12.00
4 Europa $24.00
5 Asia $27.00
zonas="1 2 3 4 5"
def costo_gramo(zona,peso):
pago=0
condicion=-1
peso=peso*1000
if zona in zonas:
if peso<=5000.0:
if zona=="1":
costo=11.0
elif zona=="2":
costo=10.0
elif zona=="3":
Pág. 71
costo=12.0
elif zona=="4":
costo=24.0
else:
costo=27.0
pago=costo*peso
condicion=1
else:
pago=0
condicion=-1
else:
#Aplicando recursividad en caso de que Ingrese una Zona No Valida
#Volvemos a llamar función de ingresar datos y luego la función se
llama así misma para proceder a su validación
zona,peso=datos_entrada()
pago,condicion=costo_gramo(zona,peso)
return pago, condicion
def datos_entrada():
zona=input("1. America del Norte 2. America Central 3. America
del Sur 4. Europa 5. Asia:\n")
peso=float(input("Indique el Peso:"))
return zona, peso
zona,peso=datos_entrada()
pago,condicion=costo_gramo(zona,peso)
if condicion==-1:
print("ENVIO RECHAZADO, EXCEDE EL PESO")
else:
print(pago,"Costo del ENVIO")
Pág. 72
Viendo la solución planteada, recapitulamos en lo que se hizo,

primero declaramos una variable llamada zonas y a esta le asignamos una
cadena con los valores del 1 al 5, la cantidad de (zonas) que hay. También
desarrollamos dos funciones una que contendrá los datos de entrada los
cuales se encargará pedir la zona y el peso del paquete. Luego tenemos
otra función costo_gramo, la cual determina el costo por gramo en función
de los datos pasados por parámetros a esta función, así mismo dentro de
esta función vemos la aplicación de uno de los métodos con los que cuenta
una función, la recursividad, esta lo aplicamos cuando volvemos a llamar
la función costo_gramo, en caso de que se ingresa una zona que no esté
comprendida entre 1 y 5.
Pág. 73
CAPITULO II.
Bucles
Funciones:
eval, range, break, try except
Tratamiento de cadenas:
len, upper, lower,
Variables booleanas
Contadores y Acumuladores
Validaciones
Módulos o Librerías:
import, random, time
Continuamos resolviendo Ejercicios

Pág. 74
En este II Capitulo continuaremos afianzando los conocimientos,

sintaxis y la semántica acerca de Python, con más funciones, otros
procedimientos, empezaremos a usar bucles o ciclos repetitivos, algunos
métodos poderosos en el manejo de errores y excepciones, igualmente
abordaremos el tratamiento de cadenas y diversos métodos aplicables a
estas.
Bucles
Los llamados bucles o ciclos repetitivos nos permiten automatizar
tareas o un bloque de código/ instrucciones, que requieren, se ejecuten
un número determinado de veces o que se necesita que se repitan
mientras una condición se cumpla. Igualmente son necesarios para llenar
arreglos o recorrerlos, en Python contamos con el Repita mientras (while)
y el ciclo repita para (for).
Veamos la sintaxis de los bucles:
Bucle Sintaxis
Repita mientras while condición:
instrucciones
for i in range(n):
instrucciones
Repita para
for i in "ejemplo":
instrucciones
El repita hasta lo podemos simular con un repita mientras.

En función de lo que se necesite se irán empleando los bucles, de
tal manera que la forma de proceder se adecuara en función del problema
que se desea resolver, en algún caso si necesitamos controlar que el ciclo
se repita mientras se de alguna condición que la controle el usuario
Pág. 75
usaremos el while, si, por el contrario, conocemos de antemano cuantas

veces necesitamos que un grupo de instrucciones se repitan sería lógico
usar un ciclo for.
Ejercicio 0022.
Mostrar las letras que tiene el nombre de una persona, una letra a
la vez
for x in "Miguel Ángel López Marín":
print(x)
Si bien desde el inicio del problemario se hizo énfasis en el desarrollo

de funciones propias, en este problema y los que siguen de este capítulo,
no emplearemos funciones propias, exceptuando un ejercicio para una
calculadora básica, por la simple razón, de que atenderemos el norte de
este capítulo, que está orientado al manejo de bucles, otras funciones en
Python y bucles con condiciones.
Este pequeño problema lo que plantea es recorrer (una cadena de

caracteres) nuestro nombre y mostrar cada letra que lo contiene, vale
recordar que la función in muestra si un elemento contiene a otro, y en
este caso nos apoyamos en dos funciones para resolver el problema, con
el for iniciaremos el bucle, la variable que controla este ciclo la hemos
denominado x y recorrerá este ciclo tantos elementos se encuentren en el
parámetro indicado en este caso una cadena que contiene los apellidos y
nombres de una persona, en el bloque de instrucciones que están dentro
del bucle, hemos mandado a mostrar la variable x. En cada vuelta la
variable x contendrá un carácter, consecutivamente, que corresponde a la
cadena (nombres y apellidos).
Ejercicio 0023.
Dado un nombre, determinar el tamaño(n) de la cadena, y mostrarlo
(n) veces
Pág. 76
Primero leemos o asignamos el nombre a una variable, luego

iniciamos el ciclo para y empleamos la función range para indicarle hasta
cuándo vamos hacer el recorrido, con la función range, podemos indicar
en qué valor iniciamos y cuando terminamos. Con la función len
determinamos el tamaño de una cadena de caracteres, luego como
argumento a la función len le pasamos la variable que contiene la cadena,
en este caso es la variable nombre, cerramos los dos paréntesis y
finalizamos la instrucción del repita para con dos puntos, a continuación,
la sentencia que permite mostrar la cadena. Recordemos que esta se
mostrara n veces, donde n corresponde al tamaño de la cadena.
nombre="Miguel Ángel López Marín"

for x in range (len(nombre)):
print(nombre)
Más funciones en Python
Eval
Una de las funciones más todoterreno con que cuenta el Lenguaje
Python, esta función permite resolver una expresión matemática alojada
en una variable de tipo cadena, veámoslo con un ejemplo en el prompt:
>>> variable="5+472*5"
>>> eval(variable)
2365
>>>
O bien también se pudo resolver una expresión y asignarla a una

variable
>>> a=input()
3+2-5+4/2*3
Pág. 77
>>> z=eval(a)
>>> z
6.0
>>>
Range
Esta función permite establecer rangos cuando ejecutamos un ciclo

para, bien sea en incremento o decremento, y estableciendo valor inicial y
valor final de un ciclo, veamos un ejemplo en el prompt:
>>> for x in range(5):
print(x)
0
1
2
3
4
>>>
Acabamos de iniciar un ciclo o bucle de tipo repita para hasta un

rango de 5, cuando no especificamos el valor inicial este asumirá que inicia
en 0, y el valor final será el indicado menos uno, si indicamos 5, llegara
hasta 4.
Veámoslo cuando establecemos un rango en particular, en este caso

mostrando los valores comprendidos entre 3 y 7:
>>> for x in range(3,7):
print(x)
3
4
Pág. 78
5
6
>>>
Si de repente necesitamos que el ciclo repita para incremente de 2
en 2 en cada vuelta, lo haríamos de la siguiente manera:
>>> for x in range(3,12,2):

print(x)
3
5
7
9
11
>>>
Break
La función break nos permite interrumpir el proceso y salir del ciclo
que se esta ejecutando en ese momento, veámoslo con una ilustración en
el prompt:
print(x)
if x>5:
break
3
5
7
Acabamos de hacer lo siguiente iniciamos un ciclo repita para que

inicia en 3 y finaliza en 12, saltando de 2 en 2 en cada vuelta, luego en el
bloque de instrucciones que están dentro del ciclo primero mandamos a
mostrar el valor de x, luego establecimos una condición indicando lo
Pág. 79
siguiente, si el valor de x, la variable que controla el ciclo para es mayor

que 5, ejecutamos la instrucción break y este permite interrumpir el
proceso de ese bucle en el momento y continuar con el resto de código si
lo hubiese. Para el ejemplo señalado, una vez se empieza a ejecutar el
ciclo empieza a mostrar el valor de x y justo cuando x vale más de 5,
interrumpe el proceso, y no continúa ejecutándose el bloque de
instrucciones del ciclo para.
Veámoslo con un ejemplo, pero esta vez, indicando que interrumpa

el ciclo cuando x menor a 5
print(x)
if x<5:
break
3
>>>
Una vez inicia el ciclo como x vale 3 la primera vez, y la línea 1 de

la instrucción del bloque es precisamente mostrar el valor de x, esta se
muestra la primera vez porque la condición de evaluar x e interrumpir esta
después de esta línea, una vez llega a esta, interrumpe el proceso y no
continua su ejecución, alcanzando el ciclo a mostrar solo el valor de x en
la primera vuelta (3).
Try Except:
Cuando desarrollamos un programa, este puede generar un error si
ingresamos un tipo de datos que no corresponden con lo que
programamos y puede provocar una interrupción en su ejecución. También
en algunos casos se requiere que nuestro programa haga determinada
actividad o alerte que se produjo un error. Para estos casos en Python
contamos con la Funcion Try Except, cual permite manejar los errores de
Pág. 80
una manera elegante sin que nuestro código se interrumpa en el proceso

de ejecución, ilustremos el uso de esta función con ejemplos en el prompt:
>>> try:
a=int(input("Ingresa un valor:"))
b=int (input ("Ingresa otro valor:"))
suma=a+b
print(suma)
except:
print("Introdujo un Valor No valido")
Ingresa un valor:5
Ingresa otro valor:h
Introdujo un Valor No valido
>>>
Expliquemos lo que ocurrió, iniciamos nuestra primera instrucción

con la palabra reservada try, luego dentro de esta mandamos a leer dos
variables de tipo entero, a la variable suma le asignamos el resultado de
a +b y en el bloque except, mandamos un mensaje, esto se traduce en lo
siguiente: todo lo que se desea que se ejecute mientras el programa
marcha normal lo mandamos al bloque try, y lo que deseamos que ocurra
si se produce un error en el proceso de ejecución lo instruimos en el bloque
except.
De esta manera y para el ejemplo que ilustra esta explicación, en
caso de que en el proceso de corrida se ingrese un valor que no
corresponda a un entero, en el momento de ejecutar la suma como se
interrumpe el proceso, este salta a las instrucciones que estén dentro del
bloque except, como allí esta una instrucción que muestra un mensaje,
esto es lo que muestra.
Pág. 81
Tratamiento de cadenas
Len
Esta función permite conocer el tamaño de una cadena, una lista,
diccionario también llamado arreglos asociativos en otros lenguajes de
programación. Ilustremos esta función en el prompt:
Determinar el tamaño de una cadena:

>>> nombre="Miguel Angel Lopez Marin"
>>> len(nombre)
24
>>>
A una variable llamada nombre asignamos una cadena de carácter,

luego en la siguiente instrucción tecleamos la función len y le pasamos
como argumento la variable que contiene la cadena, pulsamos enter y nos
arroja el resultado, la función len también cuenta los espacios vacíos.
Veamos otro ejemplo, mostrar una cadena tantas veces como

caracteres tenga esta:
>>> pais="VENEZUELA"
>>> for x in range (len(pais)):
print(pais)
VENEZUELA
VENEZUELA
VENEZUELA
VENEZUELA
VENEZUELA
VENEZUELA
VENEZUELA
VENEZUELA
VENEZUELA
>>>
Pág. 82
A la variable le asignamos una cadena con el texto VENEZUELA,

como esta tiene 9 caracteres, en el bloque del for se muestra 9 veces,
porque eso fue lo que programamos para el ejemplo.
Unir (concatenar) varias cadenas
Para unir el contenido de varias cadenas basta con usar el símbolo

+ entre variables o cadenas, veamos un ejemplo:
>>> nombres="Miguel Angel"
>>> apellidos="Lopez Marin"
>>> print(nombres+apellidos)
Miguel AngelLopez Marin
>>>
Sin embargo, en este ejemplo, como se observa al mostrar los dos

nombres con los apellidos estos quedan sin una separación lógica que
permita una correcta lectura, para lograr esto basta con incluir par de
comillas entre las cadenas que deseamos unir y dejar un espacio entre
comillas o si deseamos agregar un separador o coma lo agregaríamos entre
las comillas.
Quedaría así, unir las dos cadenas del ejemplo anterior con un
espacio entre estas:
>>> print(nombres+" "+apellidos)
Miguel Angel Lopez Marin
Convertir cadena a mayúscula

Con el apoyo de la función upper, podemos convertir cualquier
cadena a mayúscula, ilustremos en el prompt:
>>> nombre="miguel angel lopez marin"
>>> nombre=(nombre.upper())
>>> nombre
'MIGUEL ANGEL LOPEZ MARIN'
Pág. 83
>>>
Convertir cadena a minúscula

Si por el contrario deseamos convertir una cadena a minúscula
empleamos la función lower, veámoslo en el prompt:
>>> ide="Lopez Marin, MIGUEL ANGEL"
>>> ide=(ide.lower())
>>> ide
'lopez marin, miguel angel'
Eliminar ultimo carácter de una cadena

Basta con indicarlo de la siguiente forma, veamos:
>>> ide="miguel"
>>> ide=ide[:-1]
>>> ide
'migue'
>>>
Mostrar una cadena en forma lista

Para mostrar una cadena en forma de lista basta con aplicarle a la
cadena que la contiene el método split, vale recordar que con solo este
tratamiento no convertimos la variable que contiene la cadena a un tipo
de dato lista, simplemente mostramos su valor en el momento, ilustremos
la explicación:
>>> marcas="ferrari toyota honda mazda porshe maclaren jaguar"

>>> marcas.split()
['ferrari', 'toyota', 'honda', 'mazda', 'porshe', 'maclaren', 'jaguar']
>>>
Pág. 84
Convertir cadena a lista

Basta con indicar la variable a la que deseamos asignar la lista y
luego a la cadena que contiene la lista le aplicamos el método Split,
veamos:
>>> marcas=marcas.split()
>>> for x in marcas:
print(x)
ferrari
toyota
honda
mazda
porshe
maclaren
jaguar
>>>
Continuando con el ejemplo anterior empleamos la misma cadena,

solo que esta vez sí convertimos la variable que la contenía a un tipo de
datos lista, luego empleamos un ciclo para para recorrer la lista creada y
mostrarla, de tal manera que se aprecie el resultado de lo efectuado.
Contadores y Acumuladores
En programación en muchas ocasiones un problema requiere que
contemos o acumulemos una suma o multiplicación, para ello es necesario
hacerlo dentro de un bucle, dadas ciertas condiciones, un contador su valor
por lo general se incrementa de 1 en 1, y un acumulador su valor se
incrementa sumando el contenido original más el valor que deseamos
sumar a lo acumulado, tantas veces como lo programemos. Ilustremos el
proceso con ambas opciones.
Pág. 85
Ejercicio 0024.
Realizar un programa que permita contar los números pares entre
el 50 y el 100 y sumar estos valores.
#código en el editor
cp=suma=0
for x in range (50,100):
if x%2==0:
cp+=1
suma+=x
print(cp,"Total Numeros Pares, y Total Suma:", suma)
Inicializamos las dos variables en cero, a cp la emplearemos para

contar los números pares y la variable suma para acumular el valor de la
sumatoria de los números pares, en la primera línea indicamos que
cp=suma=0, es lo mismo que decir cp=0 suma=0, solo que en Python así
también se pueden inicializar varias variables en cero en una misma
instrucción.
Posteriormente se inicia el ciclo repita para, empleamos la función
range para indicar el rango, donde empieza y donde termina, dentro del
bucle instruimos la condición si el valor del índice del momento dividido
entre 2 el residuo es igual a cero, entonces incremente en uno el valor del
contador de pares y suma el valor de x a la variable suma, que en este
caso sería el acumulador.
Variables booleanas
Hemos hablado de diversos tipos de datos, enteros, reales, cadenas,
y de variables que almacenan estos datos, pero hay un tipo de variables
que almacena un dato de tipo booleano verdadero o falso, a las variables
que almacenan este tipo de datos se le puede llamar variable boleana, su
valor será únicamente True o False. Ilustremos un ejemplo en el prompt:
>>> a=5>5
>>> a
False
Pág. 86
>>>
Veamos otro ejemplo, un poco más completo:
>>> a=10<20
>>> a
True
>>> if a==True:
print("10 es Menor que 20")
else:
print("10 es mayor 20")
10 es Menor que 20
>>>
Validaciones
Es un bloque de código que permite que una variable o
procesamiento de información se comporte y reciba el tipo de dato que
corresponda, para ello se usan ciclos repetitivos, recursividad e incluso
también se puede acompañar de un manejo de errores para invocar otra
vez el llamado de la función o bloque de código donde se produce el error
o el ingreso del dato errado. Ilustremos este concepto con un ejercicio
práctico, veámoslo:
Ejercicio 0025.
Se requiere un programa o modulo en Python que valide el ingreso
de un email, para ello tome en cuenta lo siguiente, que contenga un
símbolo de arroba (@) y que este ubicado lógicamente, un punto(.), este
corresponde al del dominio del proveedor del correo, que su extensión en
caracteres sea mayor a 12 caracteres. Tomar en cuenta que se debe pedir
el email hasta que este sea correcto.
def validacion_email(email):
validacion=False
val=False
Pág. 87
valp=False
p=0
ca=0
for x in email:
p+=1
if x =="@" and p>4:
ca+=1
val=True
if x=="." and p>10:
valp=True
if val==True and len(email)>12 and valp==True and ca==1:

validacion=True
else:
#Si se introduce un email incorrecto entra a este Bloque
print("EMAIL Incorrecto")
em=pedir_email() #Vuelve a llamar la funcion de pedir el

email
va=validacion_email(em) #se invoca de nuevo la validacion
if va==True: # Se chequea otra vez si la informacion
resultante es correcta
print("EMAIL correcto")
return validacion
def pedir_email():
email=input("Introduzca E-mail: ")
return email
#Inicio Principal
email=pedir_email() # Invocacion de funcion que pide el email
Pág. 88
val=validacion_email(email) #invocacion de funcion que valida

email
#Mensaje que indica si email es correcto en un primer intento

if val==True:
print("EMAIL correcto")
Para el ejercicio de validación de email, tomando en cuenta el

planteamiento, se atendieron varias consideraciones, en general se
definieron 2 funciones, una para pedir el email y otra para el recorrido y
validación de los diferentes requerimientos de la composición del email.
En el inicio principio principal, a la variable email se le asigna la

función pedir email, en esta variable quedara guardado el valor que retorna
dicha función, para este caso sería la cadena que contiene el email, luego
a una variable llamada val, le asignamos la función que permite la
validación de los diferentes considerandos a evaluar si el email es correcto
y le pasamos como argumento la variable email.
Detalle de variables empleadas en la función Validacion_email y su

aplicacion:
Validación, valor inicial=False (falso), esta variable cambiara a
True(verdadero), si se cumplen los supuestos de la condición compuesta
que verifica si la longitud del email es mayor a 12, si la arroba esta después
de la posición 4 y el punto de la posición 10.
val= valor inicial False, cambia a True, luego que mediante
condición se verifica si existe una arroba y si está ubicada al menos
después de la posición 4
p= valor inicial 0, cuenta las posiciones que ha recorrido la el ciclo
para en la cadena que contiene el email, su valor incrementa en uno, por
cada vuelta que efectué el ciclo para, recorriendo la cadena
valp= hace la misma función que la variable val pero aplicada al
simbolo del punto en la cadena del email
Pág. 89
Vale destacar, que en el bloque del módulo del programa esta

medianamente documentado para una mayor claridad de cada aspecto de
las rutinas requeridas para cumplir con las exigencias del problema
planteado.
Ejercicio 0026.
Desarrolle una calculadora básica, tomando en cuenta que esta
permita realizar cálculos hasta que el usuario desee salir, validar la
operación aritmética a ejecutar.
def calculadora():
true=1
while true:
op=0
print("*****0*******")
print("*CALCULADORA*")
print("****0FF******")
print("\n")
v1= float (input())
if v1==0:
break
while op==0:
oper= input(("+ - * / %:"))
if oper=="+" or oper=="-" or oper=="*" or oper=="/" or
oper=="%":
op=1
v2= float (input())

if oper=="+":
res=v1+v2
elif oper=="-":
res=v1-2
Pág. 90
elif oper=="*":
res=v1*2
elif oper=="/":
res=v1/v2
elif oper=="%":
res=v1*(v2/100)
print("\n",round(res,3))
#llamada a la Funcion
calculadora()
print("\nGracias por Usar la calculadora")
Para el desarrollo de la calculadora emplearemos una función propia

construida para tal fin y en ella el ciclo mientras junto con el código
necesario para operaciones básicas y en nuestro programa principal estará
la invocación para que se ejecute nuestra calculadora, como se trata de
algo básico, simularemos lo que ocurre en un evento típico empleando una
calculadora. Una vez se invoca la función calculadora, primero se ingresa
un numero luego el operador aritmético y luego el otro número y
finalmente vemos el resultado, algo así es lo que hace nuestra calculadora,
además pudiendo controlar hasta cuando realizaremos cómputos con esta.
Empezamos el código en Python de nuestra función calculadora con

un bucle while que es el ciclo externo que controlara hasta cuando
deseamos salir de nuestra calculadora, como condición de control
empleamos un (True), verdadero, ya el ciclo inicia sin necesidad de
emplear ninguna variable adicional, y dentro de este, romperemos el ciclo
con la instrucción break, empleando como condición cuando se ingrese
cero en el primer número de nuestras operaciones en la calculadora.
Una vez entra al ciclo while lo primero que hace nuestra calculadora
es pedir un número, luego el operador aritmético para ello se despliega un
mensaje con las opciones disponibles, esta lectura cuenta con una
pequeña validación que solicita el operador mientras no sea correcto, luego
Pág. 91
pide el otro número y finalmente muestra el resultado. Una vez efectuado

el proceso como este se encuentra dentro del while, vuelve a empezar
todo, si en ese momento deseamos salir pulsamos el cero, se presiona
enter y el programa finaliza.
Ejercicio 0027.
Desarrollar un programa que pida una clave hasta que se ingrese la
clave correcta, debe mostrar mensaje cuando se equivoque y el de clave
correcta.
while True:
clave = input("Dime tu clave de acceso: ")
if clave != "1234":
print("Clave incorrecta")
else:
print ("Bienvenido!")
break
Este programa es una pequeña rutina típica de solicitar clave hasta
que se ingrese la correcta, iniciamos con una instrucción while True, entra
al ciclo la primera vez, solicitamos la clave vía teclado, luego mediante una
condición evaluamos si la clave ingresada es igual a la que hemos asignado
en la cadena, de ser correcta muestra un mensaje de bienvenida, y rompe
el ciclo con la instrucción break, en caso de que la clave sea incorrecta se
vuelve a ejecutar el ciclo, repitiendo todo el proceso.
Ejercicio 0028.
Elaborar un programa que pida una clave y luego de 5 intentos el
programa debe finalizar e indicarle al usuario que agoto los intentos,
ademas debe mostrar los intentos fallidos, así como indicar cada vez que
se equivoca ingresando la clave y un mensaje de Acceso autorizado cuando
sea ingresada la clave correcta.
Pág. 92
intento=0
while True and intento<5:
intento=intento+1
clave=(input("DIGITE LA CLAVE:"))
if clave=="4321":
print("Acceso AUTORIZADO")
break
else:
print("Acceso DENEGADO")
print("Numero de Intentos:",end="")
print(intento)
if intento==5:
print("LO SIENTO, INTENTOS AGOTADOS")
Este programa es similar al otro, con la salvedad que le hemos

agregado un poco de complejidad, para empezar el ciclo while True lo
acompaña un operador lógico y(and) intento<5, esto significa que el ciclo
while se repetirá mientras este sea verdadero y el valor de la variable
intento sea menor que 5.
Posteriormente, la primera instrucción luego que entra al ciclo es

incrementar en 1 la variable intento, la cual controla parte de nuestro ciclo,
recordemos que el proceso se ejecutara mientras este sea verdadero y la
variable intento sea menor que 5, seguidamente solicitamos la clave y
evaluamos mediante condición si esta es igual a la cadena comparada.
Si la clave es correcta, nos muestra un mensaje indicándonos que

el acceso está autorizado y la siguiente línea es una instrucción break la
cual rompería nuestro ciclo en ese momento, dando por finalizado nuestro
programa, pero en caso de que la clave sea incorrecta mediante condición
(else) primero se muestra un mensaje advirtiendo que el acceso esta
denegado y mostrando que lleva el primer intento fallido.
Pág. 93
El ciclo vuelve a ejecutarse y pasa por todo el proceso anterior, si

volviese a ingresar un intento fallido esta ira mostrando su valor hasta un
máximo de 5 intentos, luego mediante condición, desplegara un mensaje
que agotaste los intentos y el programa finaliza. Vale recordar que el
programa finaliza por dos opciones, o por número de intentos fallidos igual
a 5 o el ingreso de la clave correcta.
Ejercicio 0029.
Desarrollar un programa que sume los Números ingresados por
teclado, el programa debe salir cuando se pulse el cero
suma=0
n=1
while n !=0:
n= int (input("Indica un Numero:"))
suma=suma+n
print("LA suma de N numeros es:", end="")
print(suma)
Iniciamos haciendo suma igual a cero y a n la le asignamos el valor

de 1, de lo contrario nuestro ciclo jamás se ejecutaría puesto que la
variable que controla que el ciclo se repita sea n diferente de 0, suma se
inicializa en cero para que no genere error de identificación cuando
empieza la suma acumuladora de los valores ingresados, aunque en
Python las variables se van empleando en proceso de ejecución, cuando
deseamos emplear estas para procesos de sumas, empleando la misma
variable sin un valor previo, esta se debe haber inicializado en cero o el
valor que corresponda según sea el caso sino genera un error en proceso
de ejecución.
Luego de inicializada las variables suma y n iniciamos con un ciclo
while mientras n sea diferente de cero, leemos n, donde se alojará en cada
vuelta el número que deseamos ir sumando a la variable suma, una vez
que no deseamos ingresas más valores pulsamos cero cuando nos pide el
Pág. 94
número, se rompe el ciclo y muestra el valor de la suma acumulada en el

ciclo mientras y finaliza el programa.
Ejercicio 0030.
Programar una solución que permita calcular la nota definitiva de
un alumno, esta se determina mediante el promedio de sus notas, asuma
que son 5 notas.
acum=defin=0
for i in range(1,6):
nota= int (input("Indique la Nota:"))
acum=nota+acum
defin= acum/5
print ("Tu nota definitiva es:", end="")
print(defin)
Arrancamos nuestro código inicializando en cero las variables acum

y defin, acum guardara la suma de las notas ingresadas y la variable defi
alojara el promedio obtenido. Posteriormente instruimos un bucle para en
el rango de 1 hasta 6, al indicar este rango estaríamos diciendo que ejecute
el proceso 5 veces, el ultimo valor no lo toma en cuenta el rango de allí
que le indiquemos que se ejecute hasta el valor de 6.
Dentro de nuestro bloque para, pedimos la nota, seguidamente

acumula el valor ingresado en la variable acum, finalizado el bucle para.
La variable defin se le asigna la división de lo acumulado (acum) entre 5,
el total de notas ingresadas, siguiente instrucción muestra un mensaje
junto con la nota definitiva, finaliza nuestro programa.
Ejercicio 0031.
Codificar un programa que muestre su nombre tantas veces Ud. Lo
indique
Pág. 95
print("Hola, dime tu Nombre:",end="")
nombre=input()
i= int (input("Cuantas veces quieres ver tu nombre?"))
for i in range(1,i):
print(nombre)
Existen dos formas de mostrar mensajes una puede ser con la

función print, y si vamos a leer una variable, la función input admite que
se le pase como parámetro un mensaje que acompañe la lectura de una
variable, en este ejercicio tomamos el camino más largo, pero ya sabemos
que podemos abreviar.
Inicia nuestro código, pidiendo el nombre y luego nos pide cuantas
veces deseamos mostrarlo en pantalla. En función del valor ingresado se
inicia un bucle para desde uno hasta el valor ingresado anteriormente
como valor máximo del rango. En el ciclo para se muestra nuestro nombre
tantas veces lo hayamos solicitado y finaliza el programa.
Ejercicio 0032.
Elabore un programa que permita ver la tabla de multiplicar de un
numero
tabla= int (input("Cual Tabla quieres generar:"))
print(tabla*i)
Un programa clásico en cualquier lenguaje de Programación,

primera instrucción solicitamos la tabla que mostraremos por pantalla,
inicia un bucle para en el rango de 1 hasta 11 y la única instrucción que
contiene el ciclo para es mostrar el valor de multiplicado por el número de
la tabla que se haya ingresado, finaliza el bucle y con él la aplicación.
Pág. 96
Ejercicio 0033.
Codifique la solución para ver la tabla de multiplicar del 1 al 10
print("TABLA DE MULTIPLICAR")
print("______________________")
for j in range (1,11):
print(i*j)
print("-----------------")
Este programa es similar al otro con la salvedad que aquí tenemos

un ciclo para dentro de otro ciclo para, el primero permite recorrer cada
tabla, hasta 10 tablas y el segundo va mostrando los valores de cada tabla
de multiplicar, ambos ciclos se ejecutan en el rango de 1 hasta 11,
recordemos que solo llegara hasta 10 el proceso de ejecución en ambos
casos.
Ejercicio 0034.
Desarrolle un programa que permita calcular la nota final de un
número indeterminado de alumnos, la nota definitiva se obtiene del
promedio de 5 notas, además por cada alumno debe mostrar el nombre,
la definitiva y el literal que obtuvo tomando en cuenta los siguientes
criterios:
Mayor a 4.30 Literal A
Entre 4.00 y 4.30 Literal B
Menor a 4.00 Literal C
Observación: tome en cuenta que máximo puede emplear bucles y
condiciones para la solución, no emplea listas o arreglos.
res=1
while res==1:
Pág. 97
print("Dime tu Nombre:")
nombre=input()
acum=0
nota= float (input("Ingrese Nota:"))
acum=nota+acum
nota=acum/5
if nota>4.30:
letra="A"
elif nota >4.00 and nota<=4.30:
letra="B"
else:
letra="C"
print("ALUMNO:",nombre)
print("NOTA FINAL:",round(nota,2),"Literal ",letra)
print("\n\Hay mas alumnos 1.si 2. No")

res= int (input())
En el Lenguaje de Programación Python no existe el ciclo repita

hasta, sin embargo, con el mismo repita mientras lo podemos simular y
ese es el caso como se desarrolla este programa. Iniciamos nuestro código
inicializando la variable respuesta que emplearemos para controlar el ciclo
que controla el proceso por cada alumno, al darle un valor inicial igual a 1,
nos aseguramos que este entre al bucle del mientras al menos una vez,
luego al final del ciclo mediante una pregunta cambiamos el valor de la
variable que controla el ciclo, indicándole si hay o no más alumnos a
procesar.
Una vez dentro del ciclo while se pide el nombre del alumno y se
inicializa en cero la variable acum, en esta variable se almacenará la suma
de las notas de cada alumno cada vez que se ejecute el proceso. Es
Pág. 98
relevante destacar que el acumulador se inicia en cero fuera del ciclo para
pero dentro del repita mientras, de tal manera que cada vez que el proceso
se repita la variable acum, estará en cero para el próximo alumno a
procesar.
Luego inicia el ciclo repita para, en este bucle se pedirán las 5 notas
y se acumulara su valor en la variable acum, luego fuera del ciclo para,
pero aun en el ciclo mientras efectuamos el cálculo de la nota final
tomando lo acumulado en el bucle para y dividiéndolo entre el total de
notas ingresadas, seguidamente con este cálculo empezamos una
condición anidada empleando como variable de control la nota obtenida
para determinar a qué literal pertenece según el problema planteado.
Ejecutada la condición que corresponda y aun dentro del while

mostramos el nombre del alumno, su nota final y la letra previamente
calculada con la nota. Finaliza la vuelta del proceso repita mientras y se le
pregunta al usuario si hay más alumnos, si indica que no, finaliza el
programa de lo contrario todo el proceso anterior se repite para otro
alumno.
Ejercicio 0035.
Codifique un programa que permita calcular el número mayor y
menor de una lista, considere pulsar cero para salir del programa.
print("Calcular Mayor y menor de una lista <0> Para salir\n")
num=1
may=0
men=10000
c=0
while num!=0:
c=c+1
print("Ingrese el Numero:",c,"\n")
Pág. 99
num=int (input())
if num>may:
may=num
if num<men and num!=0:

men=num
print ("NUMERO MAYOR:", may)
print()
print(men," Numero Menor:\n")
print("Total Numeros Ingresados:",c-1)
Empezamos inicializando las variables num, may, men, c, la variable

num se inicia en 1 para que entre al ciclo repita mientras al menos una
vez, la variable may alojara el mayor lo inicializamos en el valor más bajo
y la variable men guardara el menor esta la inicializamos en un valor alto
y la variable c la emplearemos como contador en el ciclo while.
Siempre que calculemos un valor mayor o menos es conveniente

que el mayor tome o el primer valor de los números que se compararan o
el valor de cero, y el menor siempre debe tomar un valor muy alto o el
máximo considerado en el rango del cálculo.
Una vez empieza a ejecutarse las instrucciones del ciclo while, se

incrementa en uno el valor de c, se ingresa un número y de luego
empezamos mediante condición a determinar si ese número es mayor que
el mayor declarado al inicio entonces cambie su valor y asígnele el numero
leído, luego en otra condición independiente hacemos lo mismo pero con
el menor aquí en la instrucción inicial del bloque empleamos un operador
lógico (and), ya que empleamos para salir el cero del proceso, nuestro
código también puede tomar este como un numero entonces le indicamos
a la condición que evalúa el menor que el numero sea diferente de cero,
Pág. 100
si es así y es menor al ingresado cambie el valor de la variable que contiene

al menor (men).
El proceso se repite hasta que ingresemos cero en el número,

durante cada ejecución se evalúa si el numero ingresado es mayor al último
mayor calculado, así como al último menor calculado. Luego que finalice
el ciclo mientras, muestra en pantalla el Número Mayor de la lista de
números ingresados, así como el menor de la lista y finaliza nuestro
programa.
Ejercicio 0036.
Desarrolle un programa que permita calcular el mayor de 3
números, tantas veces como lo desee el usuario, se sugiere emplear el
cero (0) para salir del programa.
print("Calcular el Mayor de 3. [0] Cero para salir")
while True:
a= int (input("1er NUMERO"))
if a==0:
break
b= int (input("2do NUMERO"))
c= int (input("3er NUMERO"))
may=a
if b>may:
may=b
if c>may:
may=c
print("Hola, el Numero mayor es:", may)
Este programa inicia con un mensaje de titulo, iniciamos con un ciclo

mientras verdad, leemos un numero en pantalla, luego evaluamos si ese
Pág. 101
número es igual mediante instrucción break finalizamos el ciclo y con ello

el programa. De no ser cero el numero continúa leyendo dos números mas
y empieza el cálculo del mayor de los 3 ingresados.
Primero iniciamos asignando a la variable may donde quedara

guardado el mayor de lo números el valor de a, nuestro primero numero
leído y de allí partiremos a efectuar mediante ciclo condicional si este es
mayor a b, de así sustituirlo por el valor de b y así mismo haremos con c,
mediante dos condiciones independientes.
Determinado el mayor se muestra este vía mensaje y vuelve el ciclo

a ejecutarse y vuelve a calcular el mayor de 3 números ingresados, hasta
tanto se ingrese cero en el primer valor dentro del ciclo mientras.
Ejercicio 0037.
Codifique un programa que permita divorciar una mujer y muestre
sus nombres y su apellido de soltera luego del divorcio
#CHEQUEA SI ESTA CASADA

def status_mujer(nombre):
pos=0
nombre=nombre.upper()
if "DE" in nombre:
c=0
for k in nombre:
c+=1
if k=="D":
if nombre[c]=="E" and nombre[c+1]==" ":
pos=c
if pos>10:
res="Casada"
Pág. 102
else:
res=",SOLTERA"
return res,pos
#DE ESTAR CASADA LA DIVORCIA

def separar(nombre,pos):
nombre=nombre.upper()
ca=nombre[:pos-1]
return ca
#INICIO PRINCIPAL
#----------------
mujer=input("Nombre de la Mujer:")
valor,pos=status_mujer(mujer)
# Muestra el Resultado del Programa

if valor=="Casada":
print("FELICIDADES estas DIVORCIADA, AHORA ya no llevas
APELLIDO DE CASADA\n\n",separar(mujer,pos)+ ", DE NUEVO
SOLTERA")
else:
print(mujer+" es "+valor)
Para resolver este problema, lo segmentamos en dos funciones, una

que llamamos status_mujer y otra separar, la primera permite verificar si
el nombre introducido corresponde a una mujer casada y la otra función
permite divorciar a la mujer y eliminar el apellido de casada del nombre
original ingresado.
Iniciamos nuestro programa principal donde se lee el comentario #

INICIO PRINCIPAL, recordemos que cuando se programa en módulos,
estos pueden estar en un orden que no corresponde a su ejecución, lo
Pág. 103
importante, es el momento cuando se invoca su ejecución y que

previamente el modulo o función a invocar este ubicado por encima de su
invocación y si es una librería que primero se haya importado.
Seguimos, la primera instrucción es leer el Nombre de la mujer y lo

guardarmos en la variable mujer, luego mediante asignación multiple a
una variable llamada valor y otra llamada pos le asignamos la función
status_mujer y a esta función le pasamos como parámetro la variable
mujer (donde está alojada el nombre la mujer), de la ejecución de esta
función se devolverá un valor, una cadena con el texto ",SOLTERA" o
"casada" según el resultado arrojado por la función.
Luego mediante una decisión evaluamos el contenido de la variable

valor y procederemos mediante condición a lo siguiente, si el contenido de
la variable es "casada", mostramos un mensaje felicitando a la Mujer, le
notificamos que está divorciada y en la misma instrucción print invocamos
la función separar, pasándole como parámetro el nombre de la mujer y el
valor de pos, esta nos devolverá como resultado el nombre de la mujer
con su apellido de soltera y al estar en la función print allí mostrara el valor
devuelto de la función, seguidamente del nombre de la mujer,
acompañado de un mensaje indicándole que nuevamente es soltera y
finaliza el programa.
Si por el contrario el valor de la variable es diferente de "casada",
muestra el nombre de la mujer, seguidamente la variable valor y finaliza
el programa.
Detalles de las funciones empleadas
Función status_mujer:
Esta empieza inicializando la variable pos en cero, esta variable
marcara la posición cuando se esté recorriendo la cadena, luego a la
variable nombre la cual recibió por parámetro el nombre de la mujer le
aplicamos la función upper convirtiendo la cadena a mayúscula.
Pág. 104
Luego mediante una condición evaluamos si el texto "DE" el típico

asociativo que precede al apellido de casada lo contiene el nombre, de ser
así iniciamos un variable contador (c) en cero y empezamos un ciclo for,
para recorrer la variable nombre, incrementamos el valor de c en uno, y
seguidamente mediante otra condición dentro del for, evaluamos si el valor
de k, el índice que controla el for, su valor en la posición del recorrido del
nombre es igual a la letra "D", seguidamente en otra condición anidada a
la anterior, evaluamos si nombre en la posición c es igual a la letra "E" y
el nombre en la posición c + 1 es igual a espacio" ", esto se traduciría que
si encontramos el (de) y seguidamente vendría el apellido de casada o que
tiene un nombre con un asociativo (de), luego guardamos la posición de c
en la variable pos.
Fuera de toda condición o ciclo, pero dentro la función iniciamos

otro ciclo condicional evaluando el valor de pos, si este es mayor a 10
tentativamente nos permitimos afirmar que es una mujer casada y
devuelve dicha cadena con el texto "casada" si por el contrario pos es
menor a 10 devolverá el texto ", SOLTERA" y finaliza la función.
Función separar:
La función recibe dos argumentos el nombre de la mujer y la
posición donde encontró el asociativo (de) ya validado, seguidamente el
nombre se convierte a mayúscula y en la siguiente instrucción se guarda
en la variable ca solo el nombre de la mujer y apellido de soltera, para ello
asignamos la cadena del nombre hasta la posición de pos-1 y con ello
descarta el asociativo (de) junto con el apellido de casada, finalmente
retorna ca con el nombre y apellido de soltera, desde donde fue invocada
la función separar.
Pág. 105
CAPITULO III.
Importando librerías en Python
import, fractions, os
Estructura de Datos
Diccionarios, Tuplas, Listas
Actualización y consultas en estructuras de

almacenamiento
Métodos de ordenación
Funciones:
append
remove
index
Funciones esteteticas o de maquillaje
+ Resolución de ejercicios
Pág. 106
Preámbulo del capitulo
Sean bienvenidos a este 3er Capitulo, este será el postre del

problemario, veremos algunas de las estructuras de datos en Python como
listas conocidas en otros lenguajes también como arreglos, diccionarios
también llamados arreglos asociativos y tuplas, ilustraremos cada una de
estas estructuras con ejercicios, así como la explicación e ilustración de las
diversas funciones que permiten su manipulación.
Hay que destacar que mientras se avanza en el desarrollo de
problemas en el ámbito de la programación, es normal emplear todo lo
visto hasta este punto aunado a lo nuevo que ofrece el capítulo, ya que
los bucles, condiciones, lecturas e impresiones de variables es el pan
nuestro de cada día en cualquier programa y en estructura de datos.
Además, que en los últimos ejercicios propuestos para este tercer
capítulo ahondaremos y haremos hincapié en programar soluciones
orientadas a un ámbito profesional, como proyecto de programación,
dentro de las exigencias, competencias, destrezas, aptitudes y habilidades
que demanda el Subproyecto Algoritmo y Programación I para un discente
al culminar este curso curricular, de tal manera que este llegue con todas
las herramientas básicas que se necesitan en Programación II, como es el
caso de manejo y definición de funciones, así como el pase y recepción de
argumentos o parámetros, condiciones, bucles y estructura de datos
básicas. De esta manera les sirva de base en la evolución y estilo de cada
discente en su camino como futuro Ingeniero en Informática y
Programador.
Importando librerías en Python

Python en algunas ocasiones requiere que importemos algunas
librerías o módulos, disponibles en la gran biblioteca de Python, bien sea
para funciones matemáticas más complejas, trabajar con la librería grafica
como es el caso tkinter o alguna otra necesidad especial que resulta más
fácil resolverla importando una biblioteca. Veamos algunos ejemplos
Pág. 107
concretos, por ejemplo, si deseamos trabajar con suma o restas de

fracciones o llevar un numero decimal a fracciones, ilustremos en el
prompt.
Para importar cualquier modulo emplearemos la palabra reservada

import, en muchos casos cada módulo contiene varias sub-bibliotecas
entonces debemos precisar que deseamos importar, o bien podemos
indicar que importe todo de la biblioteca mencionada acompañando la
palabra import de un asterisco(import*).
En este caso importamos la biblioteca que permite manipular
fracciones y expresas sus cálculos en fracciones, para este ejemplo
sumamos 4/8 + 3/7, para ello iniciamos con la palabra Fraction luego
abrimos paréntesis le indicamos el numerador, seguido de una coma luego
el denominador de la fracción y cerramos paréntesis(argumentos),
seguidamente empleamos el operador matemático que se requiera y
repetimos el proceso con la otra fracción, pulsamos enter y el resultado
lo arrojo en fracciones tal cual.
En el siguiente ejemplo se convirtió 33.5 a numero fraccionario,
procedemos a iniciar con la Palabra Fraction luego le pasamos como
argumento a la instrucción Fraction(argumento), el numero decimal que
se desea llevar a fraccionario, pulsamos enter y dando como resultado su
número en fracción.
Estructura de Datos
Python cuenta con una amplia estructura de datos, entre ellas
tenemos listas conocidas en otros lenguajes como arreglos, tuplas y
diccionarios conocidos también como arreglos asociativos en otros
lenguajes como por ejemplo en PHP, empecemos con las tuplas.
Pág. 108
Diccionarios
Es una estructura de datos que permite que permite almacenar
información del tipo clave valor, no maneja índices, tampoco importa el
orden que son almacenados, en otros lenguajes son conocidos como
arreglos asociativos, un diccionario se define entre {} y cada clave tiene
su valor y esta se separa con: (dos puntos), ilustremos en el prompt:
Para acceder por ejemplo al valor de una clave basta con

mencionarla entre corchetes como si fuese su índice
Tuplas
Es una estructura de datos que permite almacenar múltiples valores
y de tipos de diferentes, son inmutables (no se pueden modificar), pero si
hacer consultas de sus elementos empleando índices, empaquetar y
desempaquetar valores. Su sintaxis seria la siguiente tupla("cadena1",
"cadena2",numero,"asi_sucesivamente"), Veamos un ejemplo de tupla
desde el prompt
A una variable llamada tupla le hemos asignado un conjunto de

datos, es una tupla anidada, sabemos que es una tupla por que maneja
paréntesis, al inicio y final de cada conjunto de datos. Luego a manera de
Pág. 109
ilustración mostramos el valor de la tupla en la posición 2, muestra el

numero 500 por que efectivamente es el único valor que contiene esa tupla
en dicha posición, luego hicimos lo mismo, pero en la posición (0) y (5)
mostrando respectivamente los valores que corresponden.
Empaquetado y desempaquetado de tuplas

Si algo poderoso puede mencionarse respecto a las tuplas en el
Lenguaje Python es que permite empaquetar y desempaquetar variables
de distintos tipos mediante el empleo de tuplas, veámoslo con un ejercicio
practico
Ejercicio 0038
Se requiere un programa que calcule la edad de una persona, se
pide que muestre la edad, año de nacimiento y el nombre de esta.
Requiere: uso de funciones, tuplas y documentación
# Funcion para pedir el año actual
def actual():
actual=input("Indique el Año actual")
return actual
#Funcion para ingresar los datos de la persona y retornar
#en form de tupla esos datos al programa principal
def datos():
ac=int(actual())
fn=int(input("Indique su Año de Nacimiento"))
nombre=input("Indique su Nombre")
edad=ac-fn
mis_datos=fn,nombre,edad
return mis_datos
Pág. 110
#Inicio Programa Principal

#Llamado a funcion de pedir datos
fecha_n,nombre,edad=datos()
#Salidas del Programa

print("NOMBRE:", nombre)
print(edad, " Años de Edad")
print("NACIO EN EL AÑO:", fecha_n)
Para este ejercicio se plantearon dos funciones, una para pedir el

año actual y otra para pedir el nombre y calcular la edad, en esta última
función además hacemos uso de las tuplas, a la variable (mis_datos) la
hemos vuelto una tupla empaquetando de esta manera la fecha de
nacimiento, el nombre y la edad de la persona (mediante asignación
multiple), luego con la función return devolvemos esos datos en forma de
tupla (mis_datos).
Ya en el programa principal, lo primero que hacemos es asignar a 3

variables la función datos, la cual luego de ejecutarse nos devolverá una
tupla con los datos requeridos, seguidamente empleando la función print
desplegamos los valores requeridos una vez que han sido asignados
después de ejecutada la función (desempaquetado de una tupla).
Vale destacar lo siguiente el flujo de ejecución del programa fue el

siguiente primero se invoca la función datos, luego cuando esta inicia llama
la función que pide el año actual, una vez esta regresa con el valor lo
convertimos a entero, porque en la función donde pedimos el año actual
lo leímos como cadena sin hacer la respectiva conversión, en el escenario
de no hacer la respectiva conversión de tipo este generara un error en
tiempo de ejecución al intentar restar un entero con una cadena.
Posteriormente regresa el flujo al llamado principal asignando los valores
en forma de tupla a las variables de salida y finalmente estas se muestran.
Pág. 111
Veamos una ilustración ejecutando nuestro código desde el editor de

Python:
Listas
Similar a un arreglo unidimensional, permite almacenar múltiples
valores, incluso de tipos distintos, aunque esto no es aconsejable, para su
manipulación se requieren emplear índices al igual que en los arreglos.
Una de sus características es que van cercados con corchetes a
diferencia de las tuplas que van con paréntesis. Veamos una ilustración de
listas en el prompt
Clausula append
El método (append) permite agregar elementos a una lista, su
sintaxis seria la siguiente lista.append(elemento_agregar)
Pág. 112
Clausula remove
El método (remove) permite remover elementos a una lista, su
sintaxis seria la siguiente lista.remove(elemento_a_eliminar)
index
La poderosa función index permite saber la posicion donde se
encuentra un elemento en una lista o tupla, importante resaltar, su uso se
aconseja acompañada de la función in, ya que si en la consulta el elemento
a buscar no existe generara un error.
Observación: desde horita en adelante por cuestión didáctica y de

no saturar con tantos párrafos de explicaciones, puesto que algunos
ejercicios las rutinas serán más extensas, pero en general se emplea y se
usa todo lo visto hasta aquí, solo se adicionan elementos nuevos
acoplándose a todo lo antes visto. Además, en el cuerpo de los ejercicios
irán documentadas las principales funciones y rutinas, tomando en cuenta
Pág. 113
que hasta el capítulo II, todo se explicó al detalle, ya en esta fase si has
llegado hasta aquí, seguramente tendrás una mayor agilidad para la
comprensión y resolución de problemas. Además, aconsejo que la mayor
explicación de cada problema, en este punto se despeja en la mayoría de
los casos con la práctica, resultando en este punto más didáctico y fácil de
asimilar; destacando, sobre todo, que cuentas con la solución completa
aquí en el texto y los scripts de los ejercicios en digital, que es algo
importantísimo. ¡Ánimos a escribir y ejecutar cada ejercicio
propuesto!
Ejercicio 0039.
Dadas 2 listas con nombres y cedulas, desarrolle un modulo que
permita hacer consultas sobre estas por numero de cedula, mostrar los
datos si existen y caso contrario mostrar mensaje.
Requiere: uso de funciones, clausula index, documentacion
#codigo en el editor
#Inicializacion de 2 listas una con nombres y otra con cedulas
nombres=["miguel","lopez","mariajose","celma","alejandro","alexa
nder",]
cedula=["17686198","8412963","25240708","10165571","2009184
0","10165571"]
#Funcion que permite hacer consultas de cedulas registradas
def consultar():
while True:
dato=(input("Dato a Consultar:"))
if dato in cedula:
pos=cedula.index(dato)
print("POSICION:",pos)
print("Nombre:",nombres[pos])
print("Cedula:", cedula[pos])
else:
Pág. 114
print("Dato no encontrado:")
if dato=="0":
break
# Llamado principal la función que permite hacer la consulta

consultar()
Metodos de Ordenación
Existen una gran variedad de metodos de ordenacion, sin embargo
aunque algunos lenguajes como Python cuentan con funciones que
ordenan listas de datos, pero estas ordenan la lista pero no ordenan
atendiendo requerimientos especificos por ejemplo varios vectores en
paralelos, se requieren construir funciones o metodos para ellos, aquí
emplearemos 2 metodos, el el metodo de ordenacion por insercion y
archifamoso ordenacion por burbuja, a continuacion con un ejercicio
desarrollaremos un programa donde se ponga en uso el ordenamiento
atendiendo el metodo de la burbuja.
Ejercicio 0040.
Desarrollar las funciones necesarias para cargar una lista de n
alumno con nombres y notas finales, ademas que genere un listador
ordenado por nombres y calcular la mayor y menor nota
Requiere: uso de funciones, metodo de ordenación por
burbuja, documentación
#Ejercicio: Cargar una Lista de N Alumnos, Notas Finales,
#Calcular la Mayor y Menor Nota junto con el Nombre del alumno
#Contiene Funciones con pase de parametros, arreglos, metodo de
ordenacion por burbuja,llamado y ejecucion de funciones
nombres=[]
notas=[]
Pág. 115
#funcion decorativa
def linea():
print("_",end="")
print()
#funcion que permite ordenar los alumnos por nombre

ascendetemente
def ordenar(n,nombres,notas):
for i in range (0,n-1):

for j in range (i+1,n):
if nombres[i]>nombres[j]:
auxn=nombres[i]
nombres[i]=nombres[j]
nombres[j]=auxn
auxno=notas[i]
notas[i]=notas[j]
notas[j]=auxno
#Permite cargar los alumnos

def inicio():
n= int(input("Cuantos Alumnos tiene la Nomina"))

print("*****Cargar Datos y Nota finales de la Seccion****")
for i in range(0,n):
print("Alumno:",i,"\n_____________\n")
nom=(input("Apellidos+ Nombres & Nota Final:\n".format(i)))
valor= float(input("\n".format(i)))
nombres.append(nom)
notas.append(valor)
return n
Pág. 116
#permite imprimir el listado de alumnos

def imprimir(n,nombres,notas):
print("APELLIDOS Y NOMBRES NOTA")

linea()
for i in range (0,n):
print(nombres[i],notas[i])
#Permite calcular el alumno con la mayor nota

def mayornota(n,nombres,notas):
notamay=0
if notas[i]>notamay:
notamay=notas[i]
pos=i
return pos
#Permite calcular el alumno con la menor nota

def menornota(n,nombres,notas):
notamen=5.00
if notas[i]<notamen:
notamen=notas[i]
pos=i
return pos
#Inicio Principal y llamado de funciones
p=inicio()
ordenar(p,(nombres),(notas))
imprimir(p,(nombres),(notas))
posi=mayornota(p,(nombres),(notas))
Pág. 117
posim=menornota(p,(nombres),(notas))
linea()
print("MAYOR NOTA\n","Alumno:",nombres[posi],"Nota
Final:",notas[posi])
linea()
print("\nMENOR NOTA\n","Alumno:",nombres[posim],"Nota
Final:",notas[posim])
linea()
Ejercicio 0041.
Desarrolle un programa que permita cargar 7 numeros por teclado,
mostrar la lista original, y ordenar y mostrar empleando metodo de la
burbuja y metodo de ordenación por insercion
Requiere: Ordenamiento por metodo de burbuja e
insercion, documentación.
datos=[]
valor=int (input("Ingrese un Numero"))
Pág. 118
datos.append(valor)
#se duplica el vector original uno para el metodo por burbuja
# y el otro para el metodo de ordenacion por insercion
burbuja=insercion=datos
#Listado original
for i in range (0,7):
print(datos[i])
#ORDENACION POR INSERCION

actual = insercion[i]
j=i
#Desplazamiento de los elementos de la matriz
while j>0 and insercion[j-1]>actual:
datos[j]=insercion[j-1]
j = j-1
#insertar el elemento en su lugar
insercion[j]=actual
print("LISTA ORDENADA POR EL METODO DE INSERCCION\n\n")
print(insercion[i])
print ("FIN ORDENACION POR INSERCCION\n")
#-------------------------------------------
#ordenacion por Burbuja

for j in range (i+1,7):
if burbuja[i]>datos[j]:
aux=burbuja[i]
burbuja[i]=datos[j]
burbuja[j]=aux
Pág. 119
print("LISTA ORDENADA POR

BURBUJA\n__________________\n")
print(burbuja[i])
Ejercicio 0042.
Dado 2 listas una contiene el nombre de frutas y la otra sus codigos,
desarrollar un modulo que permita ordenar las listas según el criterio que
desee el usuario para ello, debe darle las siguientes opciones: Ordenar por
codigo o por nombre, Y debe considerar ademas si ese orden lo quiere
descendentemente o ascendentemente
Requiere: funciones, ordenacion por insercion, documentacion
frutas=["pera","mango","durazno","kiwi","manzana","melocoton","lechoz
a","mora","piña","cambur","parchita","almendra","avellana","ciruela","fre
sa","patilla"]
codigo=[4,15,20,2,13,9,25,100,1,95,45,30,16,8,20,75]
def orden(orden,tipo):
for x in range(o,len(frutas)):
xfruta=frutas[x]
xcodigo=codigo[x]
y=x
#ascendente y codigo
if orden==1 and tipo==1:
while y>0 and codigo[y-1]>xcodigo:
codigo[y]=codigo[y-1]
frutas[y]=frutas[y-1]
y=y-1
#descendente y codigo
Pág. 120

while y>0 and codigo[y-1]<xcodigo:
y=y-1
#ascendente y nombre
while y>0 and frutas[y-1]>xfruta:
y=y-1
#descendente y nombre
while y>0 and frutas[y-1]<xfruta:
y=y-1
frutas[y]=xfruta
codigo[y]=xcodigo
print("FRUTAS CODIGO\n____________")
for i in range(0,len(frutas)):
print(frutas[i]," ",codigo[i],"\n")
#inicio
ti= int (input("ORDENAR. Por (1). Codigo o por (2).Nombre: "))
print()
o= int (input("Como desea el Orden 1. Ascendente) 2.
Descendente:"))
orden(o,ti)
Funciones esteticas o decorativas

Son aquellas funciones que se emplean para adecuar la estetica y
presentacion de datos, bien sea maquillando o decorando las salidas
Pág. 121
Ejercicio 0043
Realizar un programa que lea cuatro nombres y los muestre por
pantalla, agregandole una funcion decoradora que incluya una linea por
encima y por debajo del nombre proporcional al tamaño del nombre,
ademas debe indicar cuantos caracteres tiene el nombre de cada persona
nombres=[]
#FUNCION ESTETICA Y DE SALIDA
def resaltar(nombre):
#le suma 2 posiciones para efectos de linea decoradora
p=int (len(nombre))
p+=2
#-------------------------------------------------------
for i in range (0,(p)):
print("_",end="")
print("\n",nombre)
for i in range (0,(p)):
print("_",end="")
print()
return len(nombre)

dato=(input("Hola, dime un nombre:"))
nombres.append(dato)
print(resaltar(nombres[i]),"letras tiene tu nombre\n")
Ejercicio 0044
Programar una solucion que permita cargar 4 nombres, ademas
pedirle a cada uno año de nacimiento, año actual. Considere el uso de
Pág. 122
funciones y funciones decorativas. Como salida, el programa debe saludar

a cada una de estas personas e indicarles su edad, año de nacimiento y
cuantos años cumplira el proximo año, y un mensaje de “…vuelve pronto”
para cada uno.
Requiere: funciones, documentaciones, funciones
decoradoras o esteticas
# permite declarar las listas a usar previamente
fn=[]
ac=[]
nombre=[]
#funcin que permite saludar y mostrar la edad de la persona
def saludar(id,nacim,actual):
print()
print("Hola",id, "Bienvenido a Python")
print ("Tu edad es:",actual-nacim)
print("---------------------------")
prox=(actual-nacim)+1
return prox
#Permite cargar los Nombres año de nacimiento y año actual

def leernombres():
print("Hola, por favor dime tu nombre, año de nacimiento y
año actual")
vn=(input(""))
vfn=int (input(""))
vac=int (input(""))
nombre.append(vn)
fn.append(vfn)
ac.append(vac)
#invoca la funcion de carga de los nombres

Pág. 123
leernombres()
# recorre la lista invoca la funcion de saludar y muestra mediante

argumento
# de la funcion print (llamado a funcion de saludar)
print (saludar(nombre[i],fn[i],ac[i])," Años cumples en el 2021")
print("......Vuelve Pronto")
print("....Esto es Funciones con Python")
Ejercicio 0045
Desarrolle un programa con listas precargadas ( a su gusto o los
aquí propuestos), que contengan productos y precios, debe efectuarse un
proceso de ventas por cliente, asumiendo que cada cliente puede llevar los
productos que Ud. Dispone, para ello muestre los productos en pantalla y
con una opcion de agregar, que vaya incluyendo en la compra el codigo
del producto que desea agregar, para finalizar la compra debe pulsar la
tecla cero, luego que el cliente no desee agregar mas productos, se deb
totalizar el monto de la compra y el respectivo detalle de lo que compro,
ademas el proceso debe permitir atender mas clientes si asi lo desea el
usuario
Requiere: documentacion, validacion y manejo de errores
#importacion de libreria para usar pantalla
import os
#inicializacion de listas con productos y precios
productos=["","Azucar","Mayonesa","Crema Dental 50cc","jabon de
baño","Queso","Aceite"]
precios=[0,3000,6500,3200,2000,9000,5500]
ventas=[]
venta=0
res=-1
Pág. 124
#inicia el ciclo que controla el proceso de ventas a clientes

while True:
#permite salir si la respuesta es igual a N
if res=="N":
break
os.system("cls")
#Despliega los productos en pantallas
for k in range(0,len(productos)):
print("(",k,")",productos[k])
total=0
#ciclo que controla agregar mas productos en la venta por cliente
while True:
#permite validar que si se ingresa un dato incorrecto no

aborte el programa
try:
venta=int(input("(cero para salir****-Agregar:"))
print()
total=total+precios[venta]
ventas.append(productos[venta])
print("CUENTA VA EN:**",total)
except:
print("Producto No existe, Verifique")
if venta==0 or venta==-1:
break
# permite generar el detalle de la compra
if venta==0 and total>0:
print()
print("TOTAL CUENTA:***",total)
print("SU COMPRA",ventas)
os.system("pause")
Pág. 125
#controla si desea continuar vendiendo

res=input("Desea continuar S/N:")
res=(res.upper())
Ejercicio 0046.
Desarrolle un programa de venta de productos tipo bodega
considere, los detalles requeridos para el ejercicio 45, pero tome en cuenta
aque aquí solo se permitira una venta de maximo 3 productos por cliente,
y en la pantalla debera mostrar los productos junto con los precios al
cliente para que este elija. Emplee funciones decoradoras para generar
interfaz amigable y de presentacion tanto de salida como de ingreso.
Igualmente debe totalizar y mostrar el detalle de la compra por cada
cliente, considere emplear una funcion para la compra
Requiere: funciones decoradores, validaciones,
documentacion, manejo de errores
# declaracion de listas con productos y precios
productos=[" ","Aceite","Azucar","Arroz","Atun","Leche
liquida","Mantequilla","1/2 Carton de Huevos"]
precios=[0,6500,3500,3000,5000,2000,6500,4000,]
a=b=c=-1
#funcion decoradora
def linea2():
print()
print("*",end="")
print()
#funcion decoradora
def linea():
print("_",end="")
Pág. 126
print()
#efectua la compra en funcioon de los productos comprados

def compra(ar1,ar2,ar3):
esp=","
detalle=productos[ar1]+esp+productos[ar2]+esp+productos[ar3]
costo=precios[ar1]+precios[ar2]+precios[ar3]
return costo, detalle
#inicio principal, se repite el ciclo hasta que el usuario

#pulse cero en los tres productos
true=1
while true:
if a==0 and b==0 and c==0:
linea2()
print ("GRACIAS POR PREFERIRNOS, VUELVE PRONTO")
linea2()
break
linea2()
break
print("Pulse cero en los 3 codigos para salir*****")
print ("Codigo Producto Precios")
linea()
for i in range (0,len (productos)):
print(i," ",productos[i] ," ",precios[i] )
print()
linea()
#valida que se ingresa informacion valida y que no aborte si se
genera un error en ejecucion
try:
print("Por favor indique maximo 3 Productos(solo codigos)
que desee llevar¿?...")
Pág. 127
a=int(input(""))
b=int (input(""))
c=int(input(""))
except:
print("verifique el producto, solicitado")
if a or b or c !=0:
linea2()
try:
print (compra(a,b,c), "Pesos, monto DE TU COMPRA y
Detalle, gracias por Preferirnos")
except:
print("Ud. introdujo informacion incorrecta")
linea2()
A manera de cierre de este Capitulo se propondran 2

ejercicios que requieren haber puesto en practica todo lo anterior
desde el principio del texto hasta aquí, igualmente la solucion
queda a disposicion tanto en el texto como en archivo nativo en
Python, no tenia pensado incluirle interfaces graficas, pero como
ese es nuestro proximo norte, bien vale la pena, dedicarle un
cuarto capitulo como antesala a interfaces graficas.
Ejercicio 0047
Desarrollar una aplicación empleando listas y funciones, que emule
un sistema de votacion para ello tome en cuenta los siguientes
requerimientos:
- Debe tener un Menu de opciones
- Deb contar con un modulo para (abrir el registro de candidatos
y electores, abrir y cerrar votaciones)
- Validar electores no se registren duplicados al igual que los
candidatos (para registrar candidatos o electores el sistema debe
estar abierto para registro)
Pág. 128
- Para iniciar el proceso de votaciones debe estar cerrado el

sistema de registro y debe aperturarse el sistema de votaciones
( el sistema en este punto no debe permitir agregas ma electores
o nuevos candidatos)
- Cuando empiecen las votaciones debe validar que el elector este
registrado para permitirle votar, debe validar que solo vote una
vez
- Al elector se le muestran los candidatos antes de elegir su
opcion
- Para mostrar los resultados y el ganador de las elecciones debe
haberse cerrado las votaciones y al invocar los resultados, el
sistema debe cerrarse en general, ( no permitir nuevos registros,
ni votaciones, excepto mostrar resultados)
- Si se desea volver aperturar el sistema deben eliminarse el
registro de votos y reiniciar el funcionamiento de la aplicación
desde cero (PARA ELLO minimo debio haberse dado una
eleccion)
- Ademas debe contar con una opcion de ajustes que permita
generar una clave y actualizarla, esta clave debe pedirla para
Aperturar el registro, Aperturar las votaciones, y ver el ganador,
Nueva eleccion y eliminacion de votos.
Requiere: menu con opciones, funciones, documentacion,
validaciones, manejo de errores, uso de listas, actualizaciones
sobre listas, logica de programacion, haberse leido todo el texto
y haber practicado
#Sistema de Votacion, empleando listas
#contiene algunas validaciones, pase de parametros y manejo de

errores
#importación de biblioteca para uso de pantalla(no indispensable)
import os
Pág. 129
#preregistros de cedulas y candidatos (no necesario, pero si

declarar las listas)
cedula=["17686198","20091840","25240708","19133975","159907
22","15856908"]
candidatos=["Maria","Valentina","Crisben"]
#cedula=[]
#candidatos=[]
votacion=[]
votantes=[]
apertura=False
avotacion=False
pin=False
fin=False
#FUNCION ESTETICA- IMPRIME UNOS ASTERISCOS EN UNA
LINEA, DONDE SEA LLAMADA
def linea():
print("")
for l in range(0,20):
print("**",end="")
print("")
#Permite registrar nuevos electores, aparte de los ya precargados

#igualmente valida que no se registren electores repetidos
def cargar():
dato=-1
if apertura==False:
print("POR FAVOR DEBE APERTURAR EL REGISTRO****")
return
print("Registro de Votantes")
while dato!="0" and apertura==True:
dato=(input("Cedula:"))
if dato in cedula:
print("Cedula Ya Existe")
Pág. 130
if dato !="0"and dato!="" and dato not in cedula:

cedula.append(dato)
print("Votante Agregado")
#esta funcion permite pedir una clave en algunos procesos, para

continuar
def validar():
val=False
ver=(input("\nClave**:"))
if ver==pin:
val=True
return val
#permite generar una nueva clave y si ya existe permite actualizarla

def clave(pin):
if pin==False:
cl=(input("\nIndique su Nueva Clave:"))
cc=(input("\nconfirmar clave:"))
if cl==cc:
pin=cc
print("\nCLAVE ACTUALIZADA**")
else:print("Confirmacion errada/ Clave No Cambiada")

else:
print("Clave ya asignada")
res=(input("Desea cambiarla s/n..?"))
res=(res.lower())
if res=="s":
ver=(input("\nIndique clave actual:"))
if ver==pin:
cc=(input("\nConfirmar clave:"))
Pág. 131
if cl==cc:
pin=cc
print("Clave Actualizada")
else:
print("Clave errada....")
if res=="n":
print("**Clave NO ACTUALIZADA")
os.system("pause")
return pin
#Inicia el proceso de votaciones, previamente que el registro este

cerrado y las votaciones abiertas
#igualmente valida que un elector vote una sola vez, siempre y
cuando este registrado
def votar():
dato=-1
print("\nELECCIONES PUBLICAS")
linea()
for x in range (0,len(candidatos)):
ini=0
votacion.append(ini)
while dato!="0" and apertura==False and avotacion==True:
dato=(input("\nCedula:"))
if dato not in cedula:
print("Elector NO REGISTRAD0")
if dato in cedula and dato in votantes:
print("Ya UD. VOTO")
if dato !="0" and dato!="" and dato in cedula and dato not in
votantes:
print(candidatos)
linea()
o=(input("Elegir <Pulse el Numero de Orden>"))
Pág. 132
o=int(o)
o=o-1
votacion[o]=votacion[o]+1
votantes.append(dato)
print("VOTO REGISTRADO")
#Permite registrar nuevos candidatos, aparte de los ya precargados

#igualmente valida que no se registren candidatos ya registrados
def candidato():
dato=-1
if apertura==False:
print("POR FAVOR DEBE APERTURAR EL REGISTRO****")
return
print("Registro de Candidatos**")
while dato!="0" and apertura==True:
dato=(input("Cedula:"))
if dato in candidatos:
print("Candidato Ya Existe")
if dato !="0" and dato!="" and dato not in candidatos:
candidatos.append(dato)
print("Candidato Agregado")
#Esta funcion neuralgica permite aperturar y cerrar el registro de

votacion,
#tambien invocar la funcion de actualizar la clave
def ajustes(apertura,avotacion,pin):
while True and fin==False:
print("Ajustes del Sistema:\n")
linea()
o=(input("\n1.Abrir Registro\n2.Cerrar Registro \n3.Abrir
Votaciones \n4.Cerrar Votaciones \n5.Generar Clave\n0. Salir\n"))
Pág. 133
o= int(o)
if o==1:
apertura=True
if o==2:
apertura=False
if o==3:
if validar()==True:
avotacion=True
if o==4:
avotacion=False
if o==5:
pin=clave(pin)
break
if o==0:break
return apertura, avotacion,pin
#permite totalizar los votos

def totalizar():
if avotacion==False and apertura==False:
ub=-1
ganador=0
for k in range(0,len(votacion)):
if votacion[k]>ganador:
ganador=votacion[k]
ub=k
return ub,ganador
#permite determinar quien gano las elecciones y previamente

invoca la funcion totalizar
def resultados(fin):
if avotacion==False:
Pág. 134
ub,ganador=totalizar()
print("Resultados")
linea()
print(candidatos)
print(votacion)
linea()
print ("GANADOR DE ELECCIONES:**","(",candidatos[ub],")")
print("Total Votos:","(",ganador,")")
fin=True
return fin
#PERMITE GENERAR UNA NUEVA ELECCION, PREVIAMENTE vacia

los registros de votos
def nueva(fin):
dato=""
try:
if fin==True:
for x in range(0,len(candidatos)):
candidatos.append(dato)
votacion.append(dato)
for k in range(0,len(cedula)):
cedula.append(dato)
votantes.append(dato)
linea()
print("Puede Proceder a Una NUEVA ELECCION****")
apertura=""
avotacion=""
fin=False
return fin,apertura,avotacion
except:
print("No hay una votacion previa, ni elecciones cerradas")
Pág. 135
#Inicio Principal del bucle del MENU DEL SISTEMA DE VOTACION
while True:
print("SISTEMA DE VOTACION")
linea()
op=(input("\n1.Registro \n2.Candidatos \n3.Votacion
\n4.Ajustes y Cierres \n5.Resultados \n6.NuevaEleccion.\n7.Salir\n"))
op=int(op)
if op==1:cargar()
elif op==2:candidato()
elif op==3:
if validar()==True:
votar()
else:
print("No supero la Validacion....")
elif op==4:
apertura,avotacion,pin=ajustes(apertura,avotacion,pin)
elif op==5:
if validar()==True:
fin=resultados(fin)
else:
print("Verifique Votaciones CERRADAS, y Clave de Acceso")
elif op==6:
if validar()==True:
try:
fin,apertura,avotacion=nueva(fin)
except:
print("Por favor, haga primero, una eleccion")
elif op==7: break

Pág. 136
Ejercicio 0048
Desarrolle una aplicación que permita simular un sistema de
apertura y manejo de cuentas bancarias considere los siguientes
aspectos:
- Menú con opciones
- Debe permitir registrar nuevas cuentas con nombres, cedulas y
si desea el número de cuenta y el monto de apertura
- Mover dichas cuentas, retirar y depositar dinero
- Validar disponibilidad a la hora de retirar
- Permitir consultar clientes y modificar datos excepto el saldo
- Permitir eliminar cuentas (debe verificar si existe saldo, emitir
cheque de gerencia con el saldo)
- Consulta de listado de saldos y totales depósitos y retiros por
cuenta
- Debe crearse una clave, también debe permitir actualizar la
clave, la cual deberá pedirse para modificar datos, eliminar
cuentas y transacciones superiores a 300 mil pesos, esto
incluye (nuevas cuentas, retiros y depósitos)
Requiere: menu con opciones, funciones, documentacion,
validaciones, funciones decorativas, uso de listas, actualizaciones
sobre listas, logica de programacion, haberse leido todo el texto
y haber practicado
#Ambito de Programacion: Funciones con pase y sin pase de

parametros, listas,
#Actualizacion sobre listas(Modificar, Eliminar, Agregar,
Consultar,Listar)
#Validacion de operaciones por Clave
#Editor/Interprete Version Python: 3.8.2
#Declaracion de arreglos y llamado de la libreria os

Pág. 137
#la cual permite utilizar la funcion limpiar pantalla

#Como se observa solo se declaran 2 variables globales
#El resto de variables son Locales
import os
nombres=[]
ced=[]
ahorro=[]
retiro=[]
depositos=[]
cla=False
acceso=False
#La Funcion consultar Permite ubicar un dato en el Arreglo Cedula

#Esta funcion devuelve la posicion de la Cedula si la localiza
# e Igualmente si no se encuentra igual devuelve un Valor para
comparar
#en donde se invoque su ejecucion en la aplicacion
def consultar(dato):
pos=-1
for x in range (0,len(nombres)):
if dato==ced[x]:
pos=x
return pos
#Funcion de estetica
#Imprime en Pantalla 20 asteristicos en una misma linea
def linea():
print
print("*",end="")
print("\n")
#Esta Funcion invoca ingresar la clave configurada

Pág. 138
#en aquellas situaciones donde se requiera validar una transacion

#(eliminacion de cuentas, depositos, creacion y retiros de montos
altos)
def validar():
val=False
ver=(input("\nClave**:"))
if ver==cla:
val=True
return val
#Esta funcion permite la creacion de Nuevas cuentas e igualmente

#Verifica si la cuenta existe invocando la funcion consultar
#En caso de apertura de cuentas con montos altos invoca la
funcion validar
def cargar():
c=0
ini=0
while True and acceso==True:
os.system("cls")
print("***REGISTRO DE CUENTAS BANCARIAS***\n")
linea()
val=True
c=c+1
dato=(input("\nNombre:\n".format(c)))
dato=(dato.upper())
dato1=(input("\nCedula:\n".format(c)))
dato2=float (input("\nDeposito Inicial:\n".format(c)))
p=consultar(dato1)
if dato2>300000:
val=validar()
if val==False:
print("***Clave errada")
if val==True and p==-1:
Pág. 139
nombres.append(dato)
ced.append(dato1)
ahorro.append(dato2)
depositos.append(ini)
retiro.append(ini)
print("Cuenta creada....")
if val==True and p!=-1:
print("CEDULA YA EXISTE.. VERIFIQUE****..")
res=(input("Desea incluir otro registro: s/n"))
res=(res.lower())
if res =='n':
break
#Funcion central en la aplicacion, permite gestionar todos los

depositos
#y retiros de cuentas bancarias ya creadas, e igualmente valida
mediante la
#Invocacion de la funcion validar operaciones con montos altos
def transaccion():
os.system("cls")
val=True
print("TRANSACCIONES DEPOSITOS Y RETIROS***\n")
linea()
dato=(input("Indique la Cedula de identidad:"))
dato1= float (input("Monto Transaccion:"))
pos=consultar(dato)
if pos !=-1:
print("Nombre del Cliente:",nombres[pos])
print("Saldo Actual:",ahorro[pos])
tipo=(input("\n1.CONSIGNAR \n2.RETIRAR\nOpcion:"))
if dato1>300000:
val=validar()
Pág. 140
if val==True and tipo=="1":

ahorro[pos]=ahorro[pos]+dato1
print("\n\nNuevo Saldo:",ahorro[pos])
print("***CONSIGNACION EFECTUADA****")
depositos[pos]=dato1+depositos[pos]
if val==True and tipo=="2" and ahorro[pos]<dato1:

print("...Saldo INSUFICIENTE**")
if val==True and ahorro[pos]>=dato1 and tipo=="2":
ahorro[pos]=ahorro[pos]-dato1
retiro[pos]=dato1+retiro[pos]
print("\n\nNuevo Saldo:",ahorro[pos])
print("**RETIRO PROCESADO**")
if val==False:
print("Transaccion NO COMPLETADA")
print("\nCLAVE ERRADA**")
if pos==-1:
print("REGISTRO NO EXISTE:")
print()
res=(input("Agregar Otra Transaccion s/n:"))
res=(res.lower())
if res=="n":
break
#Lista los CLientes, saldos en cuenta y Total de Operaciones por

cuenta
def clientedetalle():
if acceso==True:
os.system("cls")
print("MOVIMIENTO POR CLIENTES")
Pág. 141
print("CEDULA NOMBRES DEPOSITOS RETIROS

SALDO")
linea()
for i in range (0,len(nombres)):
print(ced[i]," ",nombres[i]," ",depositos[i]," ", retiro[i], " ",
ahorro[i])
print()
os.system("pause")
#La naturaleza de esta funcion es crear una clave que se invocara

cada vez que se vaya
#Validar una transaccion, ademas permite actualizar la clave
#Al iniciar la aplicacion, la Unica manera que accedamos a la
opciones del Menu es
#Generando una clave
def ajustes(pase,acceso):
if cla==False:
cc=(input("\nconfirmar clave:"))
if cl==cc:
pase=cc
print("\nCLAVE ACTUALIZADA**")
acceso=True

else:
print("Clave ya asignada")
res=(input("Desea cambiarla s/n..?"))
res=(res.lower())
if res=="s":
ver=(input("\nIndique clave actual:"))
if ver==cla:
Pág. 142
cc=(input("\nConfirmar clave:"))
if cl==cc:
pase=cc
print("Clave Actualizada")
else:
print("Clave errada....")
if res=="n":
print("**Clave NO ACTUALIZADA")
os.system("pause")
return acceso,pase
#Funcion Neuralgica de la aplicacion, permite consultar cuentas y

efectuar
#operaciones sobre estas cuentas, tales como modificar datos o
eliminar la cuenta
#igualmente se valida mediante clave las operaciones que se
realicen sobre estas
def buscar():
print("Consulta Rapida por cliente(0) Salir")
linea()
x=(input("\nN° Cedula a consultar:"))
if x=="0":
break
elif x!=0:
x=consultar(x)
if x!=-1:
linea()
print("\nCliente:",nombres[x],"\n\nSaldo
Actual:",ahorro[x])
op=(input("\nOPCIONES DISPONIBLES PARA
CUENTAS**\n1.Eliminar \n2.Modificar\n3.Salir\n"))
Pág. 143
if op =="1" or op=="2":
val=validar()
if val==False:
print("\nCLAVE INVALIDA...**")
if op=="1" and val==True:
print("\nDEBE EMITIRSE CHEQUE DE GERENCIA
POR:",ahorro[x])
linea()
nombres.remove(nombres[x])
ced.remove(ced[x])
retiro.remove(retiro[x])
depositos.remove(depositos[x])
ahorro.remove(ahorro[x])
print("\n\nCUENTA ELIMINADA**")
if op=="2" and val==True:

dato=(input("\nNueva Cedula:"))
dato1=(input("\nNueva Nombre:"))
dato1=(dato1.upper())
ced[x]=dato
nombres[x]=dato1
print("\n\nCUENTA MODIFICADA**")
if x==-1:
print("\nCedula asociada a Cuenta NO REGISTRADA***")
#Programa principal(Inicio)
#Invocacion de Menu de Opciones
while True:
os.system("cls")
print("Gestion de Cuentas Bancarias\n")
Pág. 144
linea()
if acceso==False:
print("\n<Generar clave>(OBLIGATORIO)/Ajustes")
op=int (input("\n1.Registrar \n2.Transacciones \n3.VerClientes
\n4.Ajustes \n5.Actualizar\n6.Salir\n\n"))
if op==1:
cargar()
elif op==2:
transaccion()
elif op==3:
clientedetalle()
elif op==4:
acceso,cla=ajustes(cla,acceso)
elif op==5:buscar()
elif op==6:break
#Fin menu e inicio Principal
Pág. 145
CAPITULO IV
Interfaces graficas
Librería tkinter
Mi primera ventana
Cajas de texto
Etiquetas
Botones
Método get
Método set
Variables
Ventanas emergentes
Pág. 146
Gracias, si has llegado a este punto, lo felicito, espero le sirva de

mucho provecho. En este capítulo, aunque no estaba originalmente
pensado, creo que, si lo considero necesario abordarlo, las interfaces
gráficas, aunque sola a manera de introducción, porque no era el
norte del texto. Pero si debería considerarse incluirse en Programación I,
así sea al final una pequeña parte de Interfaces Graficas.
Como hemos venido estudiando el Lenguaje de Programación
Python, seguiremos en esta misma línea, solo que usando su poderosa
biblioteca gráficas, además contando con la ventaja, que la sintaxis y
gramática sigue siendo la misma, solo que ahora estará orientado a la
parte gráfica. Claro está hay muchas cosas que son nuevas, pero en
general la lógica sigue siendo la misma.
Interfaces graficas o Aplicaciones GUI

También conocidos como gadgets en el coloquio informático, son
un conjunto de ventanas compuestas por objetos gráficos e imágenes, las
cuales son la esencia principal de cualquier programa de escritorio,
mediante el cual se presenta la información y permite la interacción con el
usuario, a diferencia de la programación procedimental, la programación
de interfaces graficas está orientada a objetos, todo es un objeto, todo
tiene propiedades y métodos.
Librería tkinter
Python cuenta con una poderosa biblioteca gráfica, la cual permite
el desarrollo de aplicaciones GUI ( Grafic User Interface), que de la mano
de su propio gestor de base de datos incorporado (sqlite) se convierten en
unos instrumentos muy valiosos para diseñar y desarrollar programas en
ambientes gráficos, a manera introductoria desarrollaremos algunos pocos
ejercicios empleando esta biblioteca, igualmente se introducirán nuevos
temas y conceptos propios asociados a interfaces graficas
Pág. 147
Mi primera ventana
Si hay algo que caracteriza este lenguaje es que con pocas líneas
hacemos grandes avances, aquí como buenos programadores todo lo
construiremos desde cero, aunque hay entornos de asistencia para generar
el diseño y luego acoplarlo con el código en el lenguaje que estemos
empleando. Veamos cómo se genera una ventana, con ejemplo desde el
prompt:
>>> from tkinter import*
>>> principal=Tk()
Con estas dos líneas se genera una ventana, así de sencillo al menos
una simple ventana, quedaría así
Sigamos agregándole más funcionalidades como

un título, dimensión y color de fondo, agregaríamos lo
siguiente:
>>> principal=Tk()
Pág. 148
>>> principal.title("Hola Mundo")

''
>>> principal.geometry("200x300")
''
>>> principal.config(bg="pink")
>>>
Significado de cada instrucción en mi primera ventana
Instrucción Significado
from tkinter import* Permite importar de la librería tkinter
todos sus componentes
principal=Tk() Se hace la declaración de la clase que
permitirá usar la ventana principal, esta
dependerá de la biblioteca Tk de tkinter,
Pág. 149
aquí le puse como título “principal”, pude

haberla llamado “main” o “inicio”
principal.title("Hola Mundo") Mediante la propiedad title le asignamos
el título a la ventana
principal.geometry("200x300") Con la propiedad geometry asignamos la
dimensión donde el 200 sería el ancho y el
300 el alto medido en pixeles
principal.config(bg="pink") Con la propiedad config podemos entre
muchas cosas agregarle un color de fondo
con el parámetro bg, se puede emplear
cualquier combinación de color de un
ambiente de interfaz grafica
Etiqueta o Label
Es un elemento que permite mostrar texto, en interfaces gráficas,
veamos el código necesario para mostrar una etiqueta desde el prompt.
Importante destacar: a diferencia de la programación
procedimental o en ambiente de consola, aquí no podemos
mostrar una etiqueta sin los elementos mínimos que se requieren
para desplegarla, esto involucra un marco o ventana, y así
sucesivamente para otros objetos
>>> principal=Tk()
>>> principal.title("Hola Mundo")
''
>>> principal.geometry("200x300")
''
>>> principal.config(bg="pink")
#Aqui inicia el codigo que permite desplegar la etiqueta o label
>>> etiqueta=Label(principal, text="Mi primera etiqueta",
bg="pink", fg="blue")
>>> etiqueta.pack()
Pág. 150
Visualización y empaquetado de etiquetas y cajas de texto
Existen 3 métodos para presentar y usar etiquetas, botones y cajas

de texto, estos son el método pack, método place y el método grid,
Pack: permite empaquetar y mostrar en la ventana la etiqueta o
caja de texto en forma secuencial sin atender ubicación en coordenadas
Place: permite empaquetar, mostrar y ubicar objetos atendiendo
coordenadas x, y donde x son las filas y y las columnas
Grid: permite empaquetar, mostrar y ubicar objetos en la ventana
atendiendo una forma de cuadricula o tabla, es la más profesional
Como aquí solo atenderemos un enfoque introductorio a interfaces
graficas emplearemos el método pack
Caja de texto o Entry

Es una caja de texto para ingresar información, típica en cualquier
formulario, en interfaces gráficas, para mostrar una caja de texto, el código
adicional a lo que llevamos seria el siguiente, por resultar incómodo ya en
el prompt, lo haremos en modo de edición.
Ejercicio 0049.
Realizar una interfaz gráfica que contenga título, fondo de color
azul, unas dimensiones de 100x150 pixeles, una etiqueta que diga
“Apellidos y Nombres” y una caja de texto:
Veamos la solución desde el modo de edición ejecutándolo desde el
propio editor de Python, el código necesario y resultado sería el siguiente:
from tkinter import*
principal=Tk()
principal.title("GUI en Python")
principal.geometry("250x220")
Pág. 151
principal.config(bg="blue")
"""Aqui inicia el codigo que permite desplegar la etiqueta
o label, a la etiqueta se le aplica la propiedad bg para poner
el mismo color del fondo de lo contrario las etiquetas salen en
color de fondo gris, igual que el fondo original de la ventana"""
etiqueta=Label(principal, text="Apellidos y Nombres", bg="blue",
fg="white")
etiqueta.pack()
#Aqui inicia el codigo que permite desplegar la caja de texto
entrada=Entry(principal)
entrada.pack()
"""declaracion de bucle principal que permite la interaccion en

pantalla
aqui finalizaria nuestro programa"""
principal.mainloop()
Pág. 152
Botones
Son objetos gráficos cliqueables que permiten ejecutar alguna
acción mediante la invocación de alguna función mediante la propiedad
command.
Ejercicio 0050.
Realizar una aplicación grafica que contenga todo lo del ejercicio
49, adicional a ello agregar a ello una etiqueta que indique “Año de
nacimiento”, además de una caja de texto, luego otra etiqueta que diga
“Edad” junto a otra caja de texto, ¡como título a la ventana
“Bienvenidos!!!”, por ultimo agregar un Botón que diga “Calcular”
principal=Tk()
principal.title("Bienvenidos!!!")
#ETIQUETAS Y CAJAS DE TEXTO---------------------------
etiqueta_nombre=Label(principal, text="Apellidos y Nombres",
bg="blue", fg="white")
etiqueta_nombre.pack()
caja_nombre=Entry(principal)
caja_nombre.pack()
fecha_etiqueta=Label(principal, text="Fecha de Nacimiento",

fecha_etiqueta.pack()
caja_fecha=Entry(principal)
caja_fecha.pack()
Pág. 153
fecha_etiqueta=Label(principal, text="Edad", bg="blue",

fg="white")
caja_edad=Entry(principal)
caja_edad.pack()
#-----------DECLARACION DE UN BOTON-------------------
boton_calcular=Button(principal,text="Calcular")
boton_calcular.pack()
En la siguiente página podemos apreciar el resultado de nuestra

Programación, atendiendo los requisitos del ejercicio, hasta los momentos
no hemos manipulado ningún dato, en el próximo ejercicio lo haremos
Pág. 154
Método get
Permite obtener el contenido de una caja de texto
Método set
Permite asignar un valor a una variable
Variables
Existen 3 tipos de variables en interfaces graficas con tkinter:
1. StringVar(): almacena texto o contenido alfanumérico
2. IntVar(): almacena números enteros
3. DoubleVar(): almacena números reales
Ventanas emergentes
Son pantallas graficas que permitan advertirnos de algún tipo de
contenido o de alguna acción a ejecutar o ejecutada por el usuario,
también algunas permiten confirmar, reintentar o rechazar alguna acción
próxima a ejecutarse.
Existen varios tipos de ventana, aquí les mostraremos una de
tantas, la de aceptar un mensaje después de ejecutar una acción.
Ejercicio 0051.
Se pide realizar una aplicación grafica que contenga las exigencias
del ejercicio 0050 y adicional a ello: programe la funcionalidad del botón
calcular, que al hacer clic en el botón calcule la edad de la persona, y la
ubique en la última caja de texto, además que ubique el Nombre “Pedro
Pérez” en la primera caja de texto, debe asociar el contenido del año de
nacimiento como una variable de tipo entero, la caja donde va nombre
asócielo con una variable StringVar, igualmente desplegar una pantalla
emergente que avise que le edad ha sido calculada.
Pág. 155
from tkinter import messagebox
principal=Tk()
principal.title("Bienvenidos!!!")
#declaracion de variable entera
fn=IntVar()
#limpiamos el contenido de la variable entera, sino lo hacemos
mostrara un cero
#apenas se ejecute nuestra interfaz grafica
fn.set("")
nom=StringVar()
#----------------FUNCION CALCULAR EDAD---------------
def cal_edad():
# con la propiedad delete limpiamos todo el contenido de la caja
de texto
caja_edad.delete(0,END)
edad=2020-fn.get()
#con la propiedad insert insertamos en la primea posicion el
contenido
#que se indica, en este caso la edad calculada
caja_edad.insert(0,edad)
#mediante el metodo set cambiamos el nombre de la variable
nom.set("Pedro Perez")
#-----Muestra la ventana emergente con el aviso requerido
messagebox.showinfo("Atencion", "La edad ha sido calculada")
#ETIQUETAS Y CAJAS DE TEXTO---------------------------

etiqueta_nombre=Label(principal, text="Apellidos y Nombres",
etiqueta_nombre.pack()
Pág. 156
#caja de texto y asociacion de la variable nom con la caja de texto

caja_nombre=Entry(principal,textvariable=nom)
caja_nombre.pack()
fecha_etiqueta=Label(principal, text="Fecha de Nacimiento",

#caja de texto y asociacion de la variable fn con la caja de texto

#mediante la propiedad textvariable
caja_fecha=Entry(principal,textvariable=fn)
caja_fecha.pack()
fecha_etiqueta=Label(principal, text="Edad", bg="blue",

fg="white")
caja_edad=Entry(principal)
caja_edad.pack()
#-----------DECLARACION DE UN BOTON-------------------
#asociacion del boton calcular con el evento de calcular la edad
#mediante la propiedad command, atribuible a los botones
boton_calcular=Button(principal,text="Calcular",command=lambd
a:cal_edad())
boton_calcular.pack()
Finalmente, al ejecutar nuestra interfaz gráfica así quedaría,

solamente bastara con ingresar cualquier año de nacimiento donde dice
fecha de nacimiento y presionar el botón calcular. Continuaremos
Pág. 157
ahondando en una próxima oportunidad, con interfaces gráficas y con mis

alumnos en Programación II.
Pág. 158
Bibliografías consultadas
Bahit E. (2012). Curso: Python para Principiantes. Creative Commons.

Buenos Aires – Argentina
Pinales F., Velásquez C. (2015). Algoritmos. Universidad Autónoma de

Aguas Calientes, México.
Portal Oficial de Python. Disponible en (http://www.python.org)
Portal Oficial de Pildorasinformaticas. Disponible en

(http://www.pildorasinformaticas.com)
Rodríguez A. (2015). Python Programación. Escuela Superior Politécnica

del Litoral. Creative Commons. Ecuador
Rodríguez J. (2018). Python para ESO y Bachillerato. Instituto de

Educación Secundaria López de Arenas. España
Rojas, S., Fernández, H. y Ruiz, J. (2016). Aprendiendo a Programar en

Python con mi Computador: Primeros pasos rumbo a cómputos de gran
escala en las Ciencias e Ingenierías. Creative Commons. Venezuela
Severance, C. (2015). Python para informáticos: explorando la

información. Creative Commons. Estados Unidos.
Sweigarth A. (2015). Inventa tus Propios juegos con Python. Creative

Commons. Estados Unidos
Wachenchauzer R. (2011). Algoritmos y Programación I con Lenguaje

Python. Creative Commons. Argentina

Programando Con Python - Problemario VF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programando Con Python - Problemario VF

Uploaded by

Copyright:

Available Formats

Pág.

Programando con Python:

LOPEZ MARIN, MIGUEL

Texto didáctico orientado al Fomento y Aprendizaje de la

UNIVERSIDAD NACIONAL EXPERIMENTAL DE

Edición, Diseño y Desarrollo

Creación Intelectual N° xxx xxx xxx Resolución

Pág. Índice de Contenido

38 Ejercicio 0004: Leer nuestro nombre y saludarnos

54 Ejercicio 0012: determinar si un número es positivo o negativo

100 Ejercicio 0036: Programa que permite calcular el mayor de 3

117 Ejercicio 0041: Cargar 7 números por teclado, contiene métodos

146 Librería tkinter

Se proponen ejercicios y explicaciones conceptuales ilustradas con

Texto color negro: conceptualización acerca de Semántica y

Texto color azul: permite resaltar algunas breves explicaciones,

Texto color rojo: Enumeración de cada problema, para una

Texto rojo oscuro: se reflejará las explicaciones dadas por el autor

Texto color morado: enunciado de títulos de funciones, sintaxis y

Texto color gris: indica el código de cada programa en Lenguaje

Texto color verde claro, el código fuente necesario empleado

¿Por qué Elegir Python para empezar a Programar?

En mi Modesta experiencia como Programador en ámbito

Desde la consola interactiva, en el (prompt), podemos

Si por ejemplo queremos definir 3 variables y luego sumarlos sería

como en el editor de Python las variables se van usando y en función de

Editores para Python

elegir un entorno de desarrollo o un editor profesional depende en gran

Mientras que en Python se vería de la siguiente forma:

Observando la diferencia es abismal, para el mismo ejercicio con

Ni siquiera hubiese requerido convertir ninguna cadena, este

El uso de los dos puntos: Todo inicio de una condición o bloque

Aunque bastante sencillo el ejemplo anterior, el fin es ilustrar el uso

Uso de comentarios: en este lenguaje existen 2 formas de hacer

#Mi primer comentario

""" Un comentario de Varias líneas o muy extenso y que ocupa

Extensión de código Nativo en Python

Manejo de errores, Documentación

Funciones Básicas del Lenguaje

Manejo de los tipos de datos en Python

Definición e invocación de Funciones

Al igual que en muchos lenguajes de Programación, en Python, la

o una función, en Python el identificador de una variable puede iniciar con

Identificadores correctos Identificadores incorrectos

Intercambiar valores de una variable

nombres="mama papa hijo hermana abuela nieto"

En la ilustración anterior asignamos a una variable llamada nombres

…En lo consiguiente toda vez que se inicie un Ejercicio

Luego de pulsar la tecla F5 La salida se veria asi:

Tambien podemos ejecutar el ejercicio siguiendo la siguiente ruta:

Así de sencillo y de forma tan ligera seria nuestro primer programa

En la consola interactiva el proceso fuera sido más simple veamos,

Documentación del código fuente

scrip (código fuente) no importa si es extenso o corto, se recomienda

Manejo de errores en Python

Errores Sintácticos: se produce cuando transgredes o violas

En este ejemplo, se cometieron 4 violaciones a las reglas

finalmente el ultimo error de este ejemplo fue que intentamos asignar a

Errores Semánticos: un programa puede estar sintácticamente

Errores lógicos: el orden de nuestras instrucciones o flujo de

Errores en tiempos de Ejecución: este se genera cuando

en modo de edición, a continuación, su descripción e ilustración desde el

Uso de variables no identificadas