DESCRIPCIÓN BREVE

Este documento fue creado para la materia de

programación.

Alberto Corona Alejandro

Material de apoyo, para estudiantes que
deseen aprender a programar y trabajar con
el lenguaje de Python

MATERIAL DE APOYO
PROGRAMACIÓN PYTHON
Contenido
Lenguaje Python ................................................................................................................................................. 4
Mi primer programa con Python.......................................................................................................................... 7
Ejemplo 1: Mi primer programa ...................................................................................................................... 7
Insertando valores desde el teclado con Python ................................................................................................ 8
Ejemplo 2: Escribe tu nombre ........................................................................................................................ 8
Operadores ......................................................................................................................................................... 9
Aritméticos...................................................................................................................................................... 9
Relacionales ................................................................................................................................................. 10
Operadores lógicos ...................................................................................................................................... 11
Ejercicio 3. Precio IVA .................................................................................................................................. 14
Ejercicio 4 Promedio de 5 Calificaciones...................................................................................................... 15
Estructuras de Control ...................................................................................................................................... 17
Condicionales Simples ................................................................................................................................. 17
Ejemplo 5: Usuario correcto ......................................................................................................................... 18
Ejercicio 6: Mayor de Edad........................................................................................................................... 20
Ejercicio 7: Aprobado/No aprobado.............................................................................................................. 21
Condicionales Dobles o compuestas............................................................................................................ 23
Ejercicio 8: Positivo, Negativo ...................................................................................................................... 24
Ejercicio 9: Femenino/Masculino .................................................................................................................. 25
Ejercicio 10 Venta de llantas ........................................................................................................................ 27
Estructuras Cíclicas .......................................................................................................................................... 29
Tipos de estructuras cíclicas. ....................................................................................................................... 29
Hacer-Mientras. ............................................................................................................................................ 29
Ejemplo 11 Números consecutivos .............................................................................................................. 30
Ciclo Mientras-que........................................................................................................................................ 31
Ejemplo 12. Positivo-Negativo 5 números.................................................................................................... 32
Ejercicio 13 Suma de n números.................................................................................................................. 35
Ejercicio 14: Calificaciones/Ciclos ................................................................................................................ 37
Para-Hasta ................................................................................................................................................... 40
Ejercicio 15: imprimiendo números cicloFor ................................................................................................ 40
Ejercicio 16: ParesImpares_For ................................................................................................................... 41
Ejercicio 17: La tiendita ................................................................................................................................ 44
Índice de Figuras
Figura 1 Página oficial python............................................................................................................................ 4
Figura 2 Descargar de python............................................................................................................................ 4
Figura 3 Archivo de instalación de python ......................................................................................................... 5
Figura 4 Instalación de python ........................................................................................................................... 5
Figura 5 Python en nuestro equipo .................................................................................................................... 6
Figura 6 Entorno de Desarrollo de Python ......................................................................................................... 6
Figura 7 Hola mundo con python ....................................................................................................................... 7
Figura 8 Ejecutar python con IDLE .................................................................................................................... 7
Figura 9 Bienvenido a python ............................................................................................................................ 8
Figura 10 Diagrama de flujo Precio IVA ........................................................................................................... 14
Figura 11 Programa precio IVA........................................................................................................................ 14
Figura 12 Diagrama de flujo Calificaciones...................................................................................................... 15
Figura 13 Código calificaciones Python ........................................................................................................... 15
Figura 14 Calificaciones................................................................................................................................... 16
Figura 15 Representación condicional -Diagrama de flujo............................................................................... 17
Figura 16 Diagrama de flujo Bienvenida .......................................................................................................... 18
Figura 17 Programa bienvenida con python .................................................................................................... 19
Figura 18 Diagrama de flujo Edad ................................................................................................................... 20
Figura 19 Programa Edad con python ............................................................................................................. 20
Figura 20 Diagrama de flujo Promedio condicional Simple.............................................................................. 21
Figura 21 Código python Promedio condicional simple ................................................................................... 22
Figura 22 Resultado promedio condicional simple .......................................................................................... 22
Figura 23 Condicional Doble en el díagrama de flujo ...................................................................................... 23
Figura 24 Diagrama de flujo Positivo-Negativo ................................................................................................ 24
Figura 25 Resultado programa Positivo-Negativo ........................................................................................... 25
Figura 26 Diagramas Femenino- Masculino .................................................................................................... 25
Figura 27 Resultado programa Femenino-Masculino ...................................................................................... 26
Figura 28 Diagrama de flujo la llantera ............................................................................................................ 27
Figura 29 Código python la llantera ................................................................................................................. 27
Figura 30 Resultados del programa la llantera ................................................................................................ 28
Figura 31 Bucles .............................................................................................................................................. 29
Figura 32 Ciclo Hacer-Mientras ....................................................................................................................... 30
Figura 33 Números 1-10 hacerMientras .......................................................................................................... 30
Figura 34 Diagrama de flujo ciclo-While .......................................................................................................... 31
Figura 35 Positivo-Negativo (While)................................................................................................................. 33
Figura 36 Diagrama Suma de Números (While) .............................................................................................. 35
Figura 37 Suma de Números (python) ............................................................................................................. 36
Figura 38 Calificación-Grupal........................................................................................................................... 38
Figura 39 Promedio Grupal-While (python) ..................................................................................................... 39
Figura 40 Diagrama de flujo CicloFor .............................................................................................................. 40
Figura 41 Diagrama Imprimiendo números (for) .............................................................................................. 40
Figura 42 Diagrama ParImpar_For .................................................................................................................. 42
Figura 43 Código y resultado Pares Impares_For ........................................................................................... 43
Figura 44 Diagrama La tiendita_For ................................................................................................................ 45
Figura 45 Código y resultado La tiendita_For .................................................................................................. 46
Índice de tablas
Tabla 1 Operadores Aritméticos ......................................................................................................................... 9
Tabla 2 Ejemplo operadores aritméticos............................................................................................................. 9
Tabla 3 Operadores Relacionales..................................................................................................................... 10
Tabla 4 Ejemplos de operadores relacionales .................................................................................................. 10
Tabla 5 Operadores Lógicos............................................................................................................................. 11
Tabla 6 Tablas de verdad de los Operadores ................................................................................................... 11
Tabla 9 Jerarquía de Operadores ..................................................................................................................... 12
Tabla 10 Prueba escritorio Positivo-Negativo ................................................................................................... 33
Tabla 11 Prueba escritorio-Suma de Números ................................................................................................. 36
 Lenguaje Python
Python es un lenguaje sencillo pero muy poderoso, fácil de entender y usar, gracias a su similitud al inglés le
permite al aprendiz una mayor asimilación de los comandos que se pueden emplear en la programación.
Dentro del lenguaje existen instrucciones que se requieren para diseñar aplicaciones complejas que ayuden a
resolver problemas y diseñar mejores soluciones para nuestros clientes.
Para comenzar debemos saber dónde poder adquirir el intérprete para nuestras aplicaciones, la página que
debemos consultar para descargarlo es la siguiente: [Link] en esta página podremos
encontrar lo necesario para trabajar con este lenguaje.

Figura 1 Página oficial python

En esta página nos dirigimos a la opción de descargar o downloads y de manera automáticamente enviará la
opción de descargar la versión más reciente, además brindará la posibilidad de adquirir el intérprete para otro
sistema operativo diferente a Windows ya sea Mac OS X o Linux.

Figura 2 Descargar de python

Después de haberlo descargado tenemos lo siguiente, cabe mencionar que en el momento que se lleva a cabo
este documento la última versión más reciente es la 3.9.2

Figura 3 Archivo de instalación de python

Al ejecutar la aplicación mostrará la siguiente ventana donde nos presenta las diferentes modalidades en la que
se puede llevar a cabo la instalación.
Se recomienda usar la opción Install Now ya que es la forma predeterminada para la instalación de los
programas, la siguiente opción es la de Customiza installation ahí permitirá determinar qué y donde realizar
la instalación dentro de nuestro equipo.
Cabe mencionar que es de gran importancia tomar en cuenta las opciones inferiores a la pantalla,
principalmente Add Python to PATH ya que esta permite agregar la ruta del intérprete a las variables de
entorno del sistema, con el fin de que pueda ejecutar sus aplicaciones sin importar la ruta en la que se
encuentre.

Ver video de instalación para Windows: [Link]

Figura 4 Instalación de python

Ya después de haber instalado la aplicación se podrá contar con las siguientes opciones en nuestro equipo que
se estarán usando para desarrollar nuestros programas.

Figura 5 Python en nuestro equipo

Cuando ya contemos con todo lo necesario para trabajar hay que comenzar con el desarrollo de los primeros
programas, cabe mencionar que para esta unidad se realizarán aplicaciones a nivel de consola con el objetivo
de aprender lo necesario en el manejo del lenguaje Python, para esto elegiremos nuestro editor de código IDLE
y al seleccionar File>New File crearemos nuestro entorno de trabajo donde insertaremos el código que se
usará para las aplicaciones.

Figura 6 Entorno de Desarrollo de Python

De esta manera ya estamos para iniciar a programar.

 Mi primer programa con Python
Siempre al aprender un nuevo lenguaje es importante conocer cómo crear mensajes ya que estos son de gran
utilidad al presentar o solicitar información facilitándole al usuario un mejor manejo de la aplicación.

Para imprimir un mensaje emplearemos la función llamada print() y entre los paréntesis pondremos el mensaje
que se desea presentar al usuario.

Ejemplo 1: Mi primer programa

El código de Python del mensaje a presentar

El mensaje obtenido

Figura 7 Hola mundo con python

Nota: Si podemos observar el mensaje esta entre comillas “”, lo cual indica que es una cadena que vamos a
mostrar al usuario.

Pero bueno hay que ver cómo llegamos a este resultado.

Paso 1: Abrir un nuevo proyecto.

Paso 2: Introducir la instrucción para el mensaje print (“”)

Paso 3: Ejecutar la aplicación con F5 o eligiendo la opción Run>Run Module

Figura 8 Ejecutar python con IDLE

Ya que hemos visto como presentar un mensaje en nuestra aplicación hay que ver como solicitar los datos a
los usuarios o mejor dicho como recibir los datos proporcionados y almacenarlos en variables, para esto
emplearemos otra función llamada input().
 Insertando valores desde el teclado con Python
Como lo mencionamos anteriormente se empleará la función input(), ya que permite recibir los valores desde
el teclado.

Ejemplo 2: Escribe tu nombre

Se creará un programa en el que se leerá un nombre cualquiera y mostrará un mensaje que diga “Hola” y se le
agregará el nombre dado por el usuario, es decir si se introduce Juan, deberá imprimir Hola Juan

El código en Python

El mensaje obtenido

Figura 9 Bienvenido a python

Pero, ¿Cómo lo hicimos?:

En la línea número 1 y 2 vemos que se presentan dos mensajes, uno dando la bienvenida al usuario, es
importante mencionar que este puede ser la descripción sobre lo que hace el programa para que el usuario se
pueda dar una idea del funcionamiento del mismo como por ejemplo “Este programa imprime el nombre dado
por el usuario”. El segundo mensaje es una instrucción solicitando el dato al usuario.

En la línea 3 se espera que el usuario inserte el valor solicitado, después con la función input() se captura y se
almacena en la variable llamada nombre, por último, en la línea 4 lo que se hace es mostrar el mensaje
solicitado con el valor del usuario. Sin embargo, vemos algo distinto a lo que hemos visto en el ejemplo anterior
y es el uso del operador “+” que en este caso lo que hace es concatenar (unir) la cadena “Hola” con la variable
nombre y la cadena “saludos”, dando como resultado una sola cadena con el dato proporcionado.

Antes de continuar veamos algo relacionado a los operadores.

 Operadores
Los operadores son símbolos reservados por el propio lenguaje que se utilizan para llevar a cabo operaciones
sobre uno, dos o más elementos llamados operandos. Los operandos pueden ser variables, literales y
dependiendo el tipo de operador que se emplee será el resultado obtenido, cabe mencionar que existen
diferentes tipos de operadores como lo son aritméticos, relacionales y lógicos.
Aritméticos
Con este tipo de operadores podemos realizar diferentes tipos de operaciones aritméticas algebraicas como
son: sumas, restas, multiplicación, división, a continuación, se presenta una tabla con la descripción de los
mismos.
Tabla 1 Operadores Aritméticos

Ejemplos:
Tabla 2 Ejemplo operadores aritméticos

Operadores y operaciones
12+3= 15 + 23-15=8 - 21*2=42 * 16/3=5.33 /
16%3=1 % 16//3=5 // 3**2=9 **
Relacionales
Los operadores relacionales permitirán comparar 2 o más valores dando como resultado un valor de verdadero
o falso dependiendo la condición.
Tabla 3 Operadores Relacionales

Ejemplos:
Tabla 4 Ejemplos de operadores relacionales

Operador Operación Resultado Operador Operación Resultado

> 12>3 Verdadero < 23<12 Falso
(mayor que) 3>12 Falso (menor que) 23<50 Verdadero
23>=15 Verdadero 8<=8 Verdadero
>= <=
23>=23 Verdadero 8<=10 Verdadero
(mayor o igual que) (menor o igual que)
15>=23 Falso 10<=8 Falso

Operador Operación Resultado

12 == 3 Falso
==
12 == 12 Verdadero
(igual que)
“Juan” == “Juan” Verdadero
23 != 15 Verdadero
!=
23 != 23 Falso
(diferente que)
‘a’ != ‘b’ Falso
Operadores lógicos
Los operadores lógicos o booleanos nos permiten realizar operaciones con valores de tipo verdadero o falso
(true/false).
Los diferentes operadores con los que podemos trabajar se presentan en la siguiente tabla.
Tabla 5 Operadores Lógicos

Operador Descripción
AND Verdadero sólo si los dos elementos son verdaderos
OR Verdadero si cualquiera de los elementos es verdadero
NOT Cambia el valor de Falso a Verdadero y viceversa

Es importante considerar que para el manejo de cualquiera de estos operadores debemos conocer su tabla de
verdad y asegurarnos de emplearlos correctamente.
Tabla 6 Operador AND Tabla 7 Operador OR Tabla 8 Operador Not

AND OR NOT
p q p and q p q p or q p Not(p)
v v V v v V v F
v f F v f V v F
f v F f v V f V
f f F f f F f V

Ejemplos:
AND NOT
Expresión Resultado Expresión Resultado
((12>14) and (12>=10)) NOT((12>14) or (12>=10))
F Not(F or V) F
F and V
Not(V)

((12<=14) and (12>10))

V Not((12>=14) and (12>10))
V and V V
Not(F and V)
Not(F)
OR
Expresión Resultado
((12>14) or (12>=10))
V
F or V

((12<=14) or (12>10))
V
V Or V

((12>=120) or (10==12))
F or F F
Ahora que ya hemos visto los diferentes tipos de operadores y ejemplos de los mismos es importante conocer
la prioridad de estos, es decir cuál de ellos se debe de resolver primero cuando se encuentran en una sentencia,
para esto es importante tener siempre presente la siguiente tabla donde se encuentra la jerarquía de los
operadores.
Tabla 9 Jerarquía de Operadores

En la tabla anterior se encuentran todos los operadores que ya hemos visto en páginas anteriores, pero ¿Cómo
podemos utilizarlos?
A continuación, se presentarán algunos ejemplos.
Ejemplo:
Dada la siguiente expresión vemos que existe una combinación de los diferentes operadores, ¿Pero, como
poder establecer la prioridad para resolverlo?
Not ((12-2*3)>5)
Para solucionar este tipo de ejercicios es necesario considerar la tabla que se presentó anteriormente (jerarquía
de operadores), primero debemos identificar que operadores tienen mayor prioridad para comenzar a
resolverlo.
En este caso vemos que los paréntesis tienen un nivel de prioridad mayor a los demás operadores, así que nos
centraremos en ellos primero, podemos ver que existen 2 pares de paréntesis, así que comenzaremos de
adentro hacia afuera resolviendo las operaciones que se encuentran en el paréntesis interno.
Not((12-2*3)>5)
Ya que hemos visto los paréntesis con mayor prioridad revisaremos que operaciones se deben realizar, en este
se encuentran 2 operadores, uno es la resta “–” y otro la multiplicación “*”, así que procedemos a consultar
nuevamente la tabla de las jerarquías para saber qué operación realizar primero y vemos que la multiplicación
tiene mayor relevancia que la resta, así que primero multiplicaremos y después restaremos al valor obtenido.

Not( (12-2*3) > 5)

Not( (12-6) > 5)
Not( 6 > 5)
Una vez que se han resuelto las operaciones que se encontraban en el paréntesis pasamos a resolver la
siguiente y en este caso encontramos que dentro del último paréntesis esta un operador relacional (mayor que
>) el cual está comparando 2 valores el 6 y 5 donde pregunta si 6 es mayor que 5 y el resultado es Verdadero.

Not( (12-2*3) > 5)

Not( (12-6) > 5)
Not( 6 > 5)
Not(V)

Ya que resolvimos la operación anterior notamos que aún existen cálculos pendientes, entre estos identificamos
el operador NOT el cual es parte de los operadores lógicos, por lo que es necesario consultar la tabla de verdad
de este para ver cómo funciona, en la tabla se puede percibir que al usar este operador con algún valor el
resultado será el contrario del mismo, es decir, si el valor es verdadero al negarlo el resultado será falso y si el
valor es falso al negarlo se hará verdadero, al saber esto procedemos a resolver nuestro ejercicio.

Not( (12-2*3) > 5)

Not( (12-6) > 5)
Not( 6 > 5)
Not(V)
F

El resultado de nuestro ejercicio es Falso.

Como podemos observar para resolver este tipo de ejercicios es de gran importancia conocer los diferentes
operadores antes descritos ya que permiten determinar la manera en la que se le darán solución a los ejercicios.
Bueno ya vimos algunos de los operadores que podemos emplear dentro de nuestras aplicaciones así que
continuemos con Python.
Ejercicio 3. Precio IVA
Crear una aplicación que lea el nombre y el precio de un producto al cual se le deberá agregar el 20% de IVA.
Como resultado se espera que muestre el nombre del producto y el precio con el IVA asignado.

Figura 10 Diagrama de flujo Precio IVA

El código en Python

Resultado obtenido

Figura 11 Programa precio IVA

Ver video de la solución [Link]
Ejercicio 4 Promedio de 5 Calificaciones
Crear una aplicación en la que se pida el nombre del estudiante y cinco calificaciones.
Dará como resultado el nombre y su promedio.

Figura 12 Diagrama de flujo Calificaciones

Código Python

Figura 13 Código calificaciones Python

Video de la solución [Link]

Resultado obtenido

Figura 14 Calificaciones
 Estructuras de Control
Hasta el momento se ha trabajado con aplicaciones que funcionan de manera secuencial, es decir programas
que utilizan operaciones, entradas y salidas. Sin embargo, este tipo de programación se encuentra un tanto
limitada a la hora de desarrollar aplicaciones más complejas es por ello que debemos considerar aprender a
trabajar con estructuras de control que forman parte de la programación estructurada.

Las estructuras de control que aprenderemos en las siguientes páginas son:

• Selectivas (Condicionales)
• Repetitivas (Ciclos)
Las estructuras de control permiten determinar el flujo que tomarán los datos o acciones dependiendo a los
valores que vayan tomando las variables a nivel de ejecución.

Estructuras Selectivas
Este tipo de estructuras también llamadas condicionales permiten seleccionar un camino u otro dependiendo
los datos generados o proporcionados por el usuario en nuestra aplicación.
Tipos de Condicionales

• Condicionales Simples
• Condicionales Dobles o complejas
Condicionales Simples
Son aquellas instrucciones donde se establece una condición y si se cumple se realizarán las acciones que
hayan establecido para ese caso y si no se cumple solo finalizará la aplicación.

Estructura básica de una condición: Representación en un diagrama de flujo

Si <condicion> entonces

//Acciones o instrucciones

Fin_Si

Figura 15 Representación condicional -

Diagrama de flujo

Como se ha podido ver en los diagramas de flujo una condicional se representa mediante un rombo en el cual
estará la condición.
Sintaxis básica en python
If condicion:
#Acciones

Al momento de programar las condicionales en nuestras aplicaciones debemos considerar establecer una
sangría bajo la declaración de la misma ya que esta indicará cuales instrucciones son parte de la condición.

Ejemplo 5: Usuario correcto

Crear una aplicación que lea el nombre de usuario y si el usuario es correcto muestre un mensaje que diga
bienvenido.
Cabe mencionar que usuario será un dato fijo, ejemplo “Juan”.

Figura 16 Diagrama de flujo Bienvenida

Si analizamos un poco el diagrama de flujo podemos observar que después de leer el nombre del usuario se
encuentra una condición donde se compara si el Nombre es igual a “Juan” y si la respuesta es verdadera
entonces (si) se muestra un mensaje, de lo contrario (No) se concluye con la aplicación.
 Código Python

Resultado obtenido

Figura 17 Programa bienvenida con python

Para el desarrollo de este ejercicio es importante considerar lo que se quiere mostrar como resultado y con
base a ello establecer nuestra condición.

Video de la Solución [Link]

Ejercicio 6: Mayor de Edad
Crear una aplicación donde se pida el nombre y edad de una
persona e indique si es mayor de edad, de lo contrario finalizará
la aplicación…
El mensaje que deberá mostrar es:
“¡Felicidades! Juan eres mayor de edad”

Video de la solución [Link]

Figura 18 Diagrama de flujo Edad

Código Python

Resultado obtenido

Figura 19 Programa Edad con python

Antes de continuar revisemos la solución.
Ya hemos estado trabajando con las primeras 4 líneas de código en aplicaciones anteriores y no es otra cosa
que la declaración de variables y lectura de datos. Lo novedoso de esta aplicación y con el ejercicio 4 es el uso
y manejo de las condicionales.

La condición que se ha establecido permite determinar si la edad que ha proporcionada el usuario es mayor o
igual que 18 y si se cumple dicha condición va a imprimir el mensaje de lo contrario solo se terminará la
ejecución del programa.

Ejercicio 7: Aprobado/No aprobado

Para este ejercicio retomemos el ejercicio 4 el de las calificaciones donde
pide 5 calificaciones e imprimía el promedio de las mismas, a este le
agregaremos una condición donde si el promedio es >=8 este deberá
mostrar un mensaje de “aprobado”.

Entonces comencemos…

Figura 20 Diagrama de flujo Promedio

condicional Simple
 Figura 21 Código python Promedio condicional simple

Figura 22 Resultado promedio condicional simple

Video de la solución [Link]

Condicionales Dobles o compuestas
Este tipo de condicionales a diferencia de las simples, consiste en presentar una alternativa en caso de que no
se cumpla la condición y una serie de acciones a cumplir.

Condicional Doble Simbología Diagrama de Flujo

Si <condicion> entonces

//Acciones

Si_no:

//Acciones

Fin_si

Figura 23 Condicional Doble en el

diagrama de flujo

Sintaxis básica en python

If <condicion>:

//acciones
else:
//acciones

Ahora expliquemos un poco como funciona…

Como podemos ver, este tipo de condición es muy similar a la condicional simple pero como ya lo habíamos
mencionado esta presenta una alternativa a la condición principal y se lee de la siguiente manera.
Si la condición se cumple entonces realizará las instrucciones que se encuentren en el bloque inferior de la
condición SiNo deberá realizar lo que está dentro de esta sección aquí se ponen las acciones alternativas en
caso que no se cumpla la condición.

Para el uso de este tipo de condicionales es importante saber que se hará cuando se cumpla la condición y en
caso de que no se cumpla que otras acciones realizará.
Ejercicio 8: Positivo, Negativo
Crear una aplicación que tras leer un número determine si es positivo o negativo.

Figura 24 Diagrama de flujo Positivo-Negativo

Explicación de la solución:
Dentro del diagrama de flujo se encuentra la declaración de variables para este caso es Numero el cual
almacenará el valor dado por el usuario, enseguida tenemos la lectura de los datos, después se encuentra la
condición en la cual compara si Numero es menor a 0 en caso que la condición se cumpla mostrará el mensaje
“El número es negativo”, cabe mencionar que emplea el operador más (+) para concatenar las cadenas y al
imprimir el mensaje finalizará el programa, por otro lado si no se cumple la condición imprimirá el mensaje
“Número positivo”
 Código Python

Resultado obtenido

Figura 25 Resultado programa Positivo-Negativo

Video de la solución: [Link]

Ejercicio 9: Femenino/Masculino
Crear una aplicación en el que el usuario introduzca ‘F’ o ‘M’ e imprima Masculino si es ‘M’ de lo contrario
mostrará el mensaje de Femenino.

Figura 26 Diagramas Femenino- Masculino

Podemos observar que se encuentran dos diagramas de flujo en la cual cada uno de ellos presenta una solución
al problema dado, así que revisemos la diferencia entre ellos.
El primero (lado izquierdo) realiza la declaración de las variables, en seguida se encuentra con una condicional
en la cual compara si el Género es igual a “F”, y si esto es correcto imprimirá el mensaje “Femenino”, de lo
contrario va a mostrar “Masculino”, después de visualizar el resultado ambos casos concluirán con la ejecución
del programa.
Cabe mencionar que la solución presentada en el primer diagrama está bien ya que realiza lo que se pide, pero
no está del todo correcto porque si el usuario inserta un valor diferente a los solicitados este imprimirá
“Masculino” porque así está programado debido a que no evalúa esta situación, es por ello que se presenta la
solución 2.

En el segundo diagrama (derecha) además de evaluar a F, también se ha agregado una condición adicional en
la que evalúa también a “M” e imprimirá “Masculino” y si inserta un dato diferente mostrará que el género no es
válido.

Figura 27 Resultado programa Femenino-Masculino

Video de la solución: [Link]

Ejercicio 10 Venta de llantas
Calcular el total que una persona debe pagar en una llantera, si el precio de cada llanta es de $800 si se
compran menos de 5 llantas y de $700 si se compran 5 o más.

Figura 28 Diagrama de flujo la llantera

Figura 29 Código python la llantera

 Figura 30 Resultados del programa la llantera

Video de la solución: [Link]

 Estructuras Cíclicas
El uso de condicionales en el desarrollo de las aplicaciones es de gran ayuda ya permiten crear programas más
completos, pero hay ocasiones donde es necesario leer varios datos empleando la misma instrucción y para
evitar la redundancia de código se emplean las estructuras cíclicas ya que al poner algo dentro de estas
permitirán repetir cierta instrucción n veces hasta que se cumpla un límite o condición dependiendo el ciclo que
se esté empleando.
Dependiendo el lenguaje es la manera en la que se podrán implementar ya que este establece los lineamientos
en cuanto a la sintaxis, por ejemplo: si lleva llaves o no, si tiene sangrías para determinar las acciones o no,
etc., es por ello que debemos primero investigar como emplearlas en el lenguaje que vayamos a trabajar.
Pero en esencia todos trabajan de la misma manera sin importar el lenguaje, es decir un ciclo es un bucle que
se repite una y otra vez y este puede ser infinito si uno no establece un límite o instrucción que lo controle.

Figura 31 Bucles

Tipos de estructuras cíclicas.

• Hacer-mientras (do-while)
• Para-hasta (for)
• Mientras-que (while)

Explicación breve de los diferentes tipos de ciclos.

Hacer-Mientras. - Este tipo de condición como se puede entender consiste en repetir una o un conjunto de
instrucciones tantas veces hasta que se cumpla una condición.

Ejemplo: Descripción: Como podemos observar en este tipo de ciclo

se requiere de un contador donde su principal función es
Contador=1 contar el número de veces que se repite el ciclo y en cada
Hacer
iteración mostrará el mensaje que se encuentra dentro del
Mostrar “Hola mundo” bloque Hacer-Mientras, este ciclo se repetirá mientras se
Contador=Contador+1
cumpla la condición y se detendrá cuando ya no lo haga.
Mientras que n<5
Nota: Su principal característica es que primero realiza las
acciones sin importar si se cumple o no la condición
 Descripción: Como podemos observar en la figura 32 el
flujo entra en el ciclo realizando las acciones que están
establecidas dentro del mismo, después de llevar a cabo las
acciones se encuentra una condicional la cual dependiendo
el resultado se determinará la dirección del flujo.
Si la condición se es verdadera este se regresará al inicio
del ciclo realizando nuevamente las instrucciones, en caso
que no se cumpla (falso) este dirigirá el flujo fuera del ciclo
continuando con la siguiente instrucción o finalizando la
aplicación.

Figura 32 Ciclo Hacer-Mientras

Ejemplo 11 Números consecutivos

Crear una aplicación el cual imprima los números consecutivos del 1 hasta el 10 empleando la estructura cíclica
Hacer-Mientras

Análisis previo:

Para realizar este programa lo primero es conocer cómo funciona el ciclo hacer-mientras
De acuerdo a lo que se pide no es necesario solicitar ningún valor ya que solo pide imprimir un número
secuencial del 1 al 10, y para esto podemos hacer uso del mismo contador que estará presente en las
instrucciones.

Inicio
1. contador=1
2. Hacer
2.1. Mostrar contador
2.2. contador=contador+1
3. mientras contador<=10
Fin

Figura 33 Números 1-10 hacerMientras

El pseudocódigo presentado hace referencia a la impresión de los números del 1 al 10, y como habíamos
mencionado al inicio, lo primero que encontramos es el contador el cuál usaremos para contar las iteraciones,
al entrar en el ciclo se tiene la impresión del contador que por primera vez tiene el valor de 1 ya que así fue
definido al inicio, enseguida este irá incrementando conforme avance el ciclo, luego tenemos la siguiente
instrucción contador=contador+1 con esta instrucción lo que queremos dar entender es que lo que tiene
contador se le sume 1 y el resultado será almacenada en la misma variable contador por último se encuentra
la condición encargada de determinar si la aplicación continua o finaliza, en este caso el ciclo continuará
mientras contador sea menor o igual a 10 y cuando ya no se cumpla finalizará el ciclo, dando paso a la siguiente
instrucción.
Cabe mencionar que para el lenguaje de Python no tiene este tipo de ciclo, pero en los demás lenguajes si lo
podemos encontrar.
Ciclo Mientras-que
Este tipo de ciclo al igual al anterior dependen para su funcionalidad de una condición el cual determina si
continua o concluye, este se caracteriza por tener una condición al iniciar como se puede ver en el ejemplo

Sintaxis básica Pseudocódigo Sintaxis básica python

Mientras que <condicion>

while <condicion>:
//Instrucciones
//instrucciones
//Contador
//contador
Fin_Mientras

Diagrama de flujo

Descripción: Este tipo de ciclo consiste en

evaluar primero la condición y si ésta se
cumple realizará las acciones que se han
establecido en el mismo.
Nota: Su principal característica consiste en
que la evaluación esta al inicio y de no
cumplirse no realizará nada (primero evalúa
luego realiza)

Figura 34 Diagrama de flujo ciclo-While

Ejemplo 12. Positivo-Negativo 5 números
Crear una aplicación que pida 5 números e indique cuántos de los números insertados son positivos y cuántos
negativos.

Para el desarrollo de esta aplicación se aplicará la estructura cíclica Mientras-que (While).

Pseudocódigo Positivo-Negativo

Variables
Numero, contador=1, positivo, negativo variables de tipo numérico Entero
Inicio
Mientras que contador<=5
Mostrar “Insertar el número ”+contador
Leer Numero
Si Numero>0 entonces
positivo=positivo+1
sino
negativo=negativo+1
Fin_Si
contador=contador+1
Fin_Mientras
Mostrar “De los números insertados son ”+positivo+ “ positivos y ”+negativo + “
negativos”
Fin
Diagrama de flujo Positivo-Negativo

Figura 35 Positivo-Negativo (While)

Prueba de escritorio
While
No contador Positivo Negativo Numero Numero>0 Operación contador=contador+1
contador<=5
positivo=positivo+1
1 0 0 1<=5 V 5 5>0 V 1 contador=1+1 2
positivo=0+1
positivo=positivo+1
2 1 2<=5 V 4 4>0 V 2 contador=2+1 3
positivo=1+1
negativo=negativo+1
3 2 1 3<=5 V -7 -7>0 F 1 contador=3+1 4
1 negativo=0+1
positivo=positivo+1
4 3 4<=5 V 9 9>0 V 3 contador=4+1 5
positivo=2+1
negativo=negativo+1
5 2 5<=5 V -100 -100>0 F 2 contador=5+1 6
negativo=1+1
6 6<=5 F
Tabla 10 Prueba escritorio Positivo-Negativo
Código Python Positivo-Negativo

Resultado

Video del ejercicio: [Link]

Expliquemos el ejercicio:
Para comenzar, en el ejercicio se declaran las variables que se usarán dentro de la aplicación y para este caso
se han definido con un valor inicial y una de las que resalta es la variable contador que se inicializa en 1 ya
que es la que emplearemos para el ciclo, después se encuentra el inicio del ciclo donde se lee de la siguiente
manera mientras contador sea menor o igual que 5 realizará las acciones definidas en este, de lo contrario
terminará el ciclo.

Al entrar en el ciclo lo que se tiene es la lectura del número que proporcione el usuario y enseguida se encuentra
una condición la cual compara si numero es mayor a 0 y si el resultado de la comparación es verdad deberá
incrementar el valor de positivo, de lo contrario lo que hará será incrementar a negativo, después fuera de las
condicionales encontramos el incremento del contador donde se dice que lo que tiene contador se le suma 1 y
se almacena en la variable con el mismo nombre, por ultimo lo que se tiene es la impresión del resultado
Ejercicio 13 Suma de n números
Crear una aplicación que pida N números y realice la suma de los mismos, para el desarrollo de esta aplicación
se deberá emplear la estructura cíclica while.

Pseudocódigo SumadeNumeros
Variables
cant, numero, cont=1, suma=0 son de tipo numérico entero
Inicio
1. Mostrar “Esta aplicación realizar la suma de n números proporcionados por el usuario”
2. Mostrar “Introduce la cantidad de números a leer”
3. Leer cant
4. Mientras cont<=cant
a. Mostrar “Insertar el número” +cont
b. Leer numero
c. suma=suma+numero
d. cont=cont+1
5. Fin_mientras
6. Mostrar “La suma de los números insertados es:” +suma
Fin

Diagrama de flujo

Figura 36 Diagrama Suma de Números (While)

Video del ejercicio: [Link]

 Prueba de Escritorio
No. cant cont Suma cont<=cant numero suma=suma+numero cont=cont+1 S
0 0 1 0 0
5 2 7 1<=5 V 7 suma=0+7 7 cont=1+1 2
3 11 2<=5 V 4 suma=7+4 11 cont=2+1 3
4 13 3<=5 V 2 suma=11+2 13 cont=3+1 4
1
5 25 4<=5 V 12 suma=13+12 25 cont=4+1 5
6 28 5<=5 V 3 suma=25+3 28 cont=5+1 6
6<=5 F 28
Tabla 11 Prueba escritorio-Suma de Números

Figura 37 Suma de Números (python)

Explicación del ejercicio

Cabe mencionar que para realizar este ejercicio se debe considerar el uso de contadores y acumuladores, para
este se debe leer la cantidad de números a introducir, después se tiene la condición del ciclo que mientras
cont<=cant, es decir si el contador es menor o igual a la cantidad, y si se cumple la condición pedirá el primer
número, enseguida se hace uso de un acumulador que como lo dice va acumulando los diferentes valores
insertados por el usuario, al realizar esta instrucción se incrementa el contador al ser incrementado se vuelve a
ejecutar la condición del ciclo y si se cumple seguirá solicitando valores y sumándolos hasta que el contador
sea mayor a la cantidad ingresada y de esta manera finalizaría el ciclo dándole pasa a las siguientes
instrucciones.
Ejercicio 14: Calificaciones/Ciclos
Crear una aplicación donde pida 5 calificaciones de n estudiantes e imprima el promedio por estudiante y el
promedio general de los estudiantes ingresados.

Pseudocódigo calificacionesCiclo

Variables
NoEstudiantes, calif, nombre, prom, promGral, cont=1, cont2=1 tipo numérico entero
Inicio
1. Mostrar “Esta aplicación lee calificaciones de n estudiantes y muestra sus promedios”
2. Leer NoEstudiantes
3. Mientras cont<=NoEstudiantes
a. Mostrar “Escribe el nombre del alumno”
b. Leer nombre
c. Mientras cont2<=5
i. Mostrar “Introduce la calificación” +cont2
ii. Leer calif
iii. prom=prom+(calif/5)
iv. cont2=cont2+1
d. Fin_Mientras
e. Mostrar nombre+ “tu promedio es” +prom
f. cont2=1
g. cont=cont+1
h. promGral=promGral+(prom/NoEstudiantes)
i. prom=0
4. Fin_Mientras
5. Mostrar “El promedio general del grupo es:” +promGral
Fin
Diagrama de flujo calificacionEstudiantes

Figura 38 Calificación-Grupal
 Figura 39 Promedio Grupal-While (python)

Explicación:
Esta aplicación cuenta con ciclos anidados en donde el primero se encarga de llevar el conteo de los estudiantes
que se capturarán en el programa, el segundo de los ciclos llevará el control de las calificaciones ingresadas
por el usuario.

Es importante saber que el programa emplea acumuladores que almacenarán las valores y se irán acumulando
con forme vaya tomando nuevos valores.

Video del ejercicio: [Link]

Para-Hasta
Este ciclo consiste en poner inicio, fin y una forma de incremento o decremento, cabe mencionar que este no
depende de una condición y lo podremos emplear en situaciones en las que conocemos el inicio y el fin de las
iteraciones que deseamos realizar.
Estructura básica pseudocódigo
Para <valorInicial> hasta <valorFin> --Incremento/Decremento
//Acciones
Fin_Para

Estructura básica Python

for n in range(<valorInicia>,<Fin>, <incremente/decremento>):
//Instrucciones

Figura 40 Diagrama de flujo CicloFor

Para el código en Python la “n” hace referencia a la variable que contendrá el valor de cada una de las
iteraciones, range () se usa para establecer un rango de iteraciones, es decir, un inicio y un fin, así como para
incluir de qué manera se llevará el incremento o decremento.
Ejercicio 15: imprimiendo números cicloFor
Si deseamos crear una aplicación que imprimir los números del 1 al 10 y que su incremento se realice de 2 en
2 se deberá realizar de la siguiente manera.
Pseudocódigo ImprimirNumeroFor
Para i=1 hasta i<=10 incrementar en 2
Mostrar “i”

Código ImprimirNumeroFor en Python

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

Figura 41 Diagrama Imprimiendo números (for)

Video de Ejercicio: [Link]

Ejercicio 16: ParesImpares_For
Crear una aplicación donde solicite la cantidad de números a insertar e indique si es un número par o impar e
indique cuales son:
Pseudocódigo parImpar_For
Variables
Final, numero, par, impar tipo de dato número Entero
Npar, Nimpar tipo de dato cadena
Inicio
Mostrar “Introduce la cantidad de números a leer”
Leer Final
1. Para i=1 hasta i<=Final incremento 1
a. Mostrar “Inserta el número ”+i
b. Leer numero
c. Si (numero%2) ==0 entonces
i. par=par+1
ii. Npar=Npar+numero
d. Si_no
i. impar=impar+1
ii. Nimpar=Nimpar+numero
e. Fin_Si
2. Fin_Para
3. Mostrar “Hay ”+par+” y son ”+Npar
4. Mostrar “Hay ”+impar+” y son ”+Nimpar
Fin
Diagrama de Flujo ParImpar_For

Figura 42 Diagrama ParImpar_For

Código en Python y resultado de ParesImpares

Figura 43 Código y resultado Pares Impares_For

Video del Ejercicio: [Link]

Ejercicio 17: La tiendita
Crear una aplicación en la que simule una compra de N productos donde muestre el total a pagar y con base
al pago determine el cambio que se le dará al cliente.

La forma en que se deberá mostrar será la siguiente:

Productos comprados: 8
Total, a pagar: $150
Denominación de pago: $200
Cambio: $50

Pseudocódigo La Tiendita
Variables

cantProd, precio, total, cambio, suma, pago tipo de dato numérico entero
Inicio
1. Mostrar “Esta aplicación calcula el total a pagar de n productos”
2. Mostrar “Inserta la cantidad de productos”
3. Leer cantProd
4. Para i=1 hasta i<=cantProd incremento 1
a. Mostrar “Precio del producto” +i
b. Leer precio
c. suma=suma+precio
5. Fin_para
6. Mostrar “Productos comprados:” +cantProd
7. Mostrar “Total a pagar: $” +suma
8. Mostrar “Denominación de pago $”
9. Leer pago
10. cambio=pago-suma
11. Mostrar “Cambio: $” +cambio
Fin
 Diagrama de flujo

Figura 44 Diagrama La tiendita_For

Código en Python y resultado de La Tiendita

Figura 45 Código y resultado La tiendita_For

Video del ejercicio [Link]