Material complementario

Tipos de datos
Código 03564

Preparada por

LIC. Marvin Suárez Benson

 EQUIPO DE T RABAJO

Encargado de carrera

Mag. Patricia Sagot Carvajal

Este material complementario ha sido

confeccionado en la Cátedra Registros de Cátedra Registros de Salud

Salud de la Escuela de Ciencias Exactas y

Lic. Moisés Méndez Coto
Naturales en el año 2024, para uso exclusivo

del estudiantado de la asignatura de Lógica Y

Autor del material complementario de estudio
Algoritmos para Sistemas de Información en

Salud (código 03564), que se imparte en la

Lic. Marvin Suárez Benson
Carrera de Sistemas de Información en Salud

de la Universidad Estatal a Distancia.

Este es un material no comercial y se encuentra

prohibida su venta.

ii
Presentación

Por medio del presente documento se procura que la persona estudiante

adquiera conocimiento a nivel teórico y práctico, relacionado con las normativas

vigentes que giran a nivel país en los sistemas de información, además de los
diferentes reglamentos, leyes y procesos que los mismos las envuelven, se pretende
brindar un enfoque que permita obtener una serie de conocimientos sobre los

diferentes marcos de trabajos, regulaciones de datos y los respaldos que las leyes en
nuestro país nos respaldan, conocer cual entidad es la encargada de estas
regulaciones y velar por el cumplimiento relacionado a la protección de los datos de

los ciudadanos.
Es de suma importancia contar con claridad de cuáles son los marcos de

normalización para los sistemas de información en salud, los más utilizados y una
serie de características que se deben de tomar en cuenta al momento del diseño de
un sistema de información y la importancia de utilizar estándares en el desarrollo,

para futuras integraciones entre diferentes sistemas o bien la actualización de estos

y a su vez las arquitecturas más usadas para sistemas de información en salud.
Importante contar con conocimiento sobre las diferencias entre los manuales

instructivos y procedimientos de sistemas de información en salud ya que ambos

son material didáctico de suma importancia para los sistemas de información, con
la diferencia que ambos son dirigidos a diferentes involucrados tanto en el uso como

el desarrollo de los sistemas de información.

Aplicar los conocimientos teórico-prácticos de la normalización de los
sistemas de información en salud desarrollando estrategias de gestión de la

información que integre políticas, estándares, procedimientos y métodos en las

organizaciones de tecnología-salud de forma ética y moral.

4
Contenido

Presentación ..................................................................................................................... 4

Unidad 2: Tipos de datos ............................................................................................... 9

2.1 Tipos de datos en programación ..................................................................................... 9

2.2 Introducción a las funciones ..........................................................................................12

2.2.1 Funciones para convertir tipos de datos .......................................................................14

2.2.1 Funciones matemáticas .............................................................................................15

2.2.3 Función para generación de números aleatorios ............................................................16

2.2.4 Repaso de operadores matemáticos ............................................................................17

2.3 Creación de funciones ..................................................................................................20

2.3.1 Creación de variables dentro de funciones....................................................................22

2.4 Uso del estatuto “return” .............................................................................................24

2.5 Uso de la función Lambda .............................................................................................26

2.6 Aspectos a considerar el desarrollo de un programa .........................................................27

2.7 Iteración.....................................................................................................................30

2.7.1 Actualizando una variable ..........................................................................................30

2.7.2 La sentencia “while”..................................................................................................31

2.7.3 Bucles infinitos y estatuto “break” ...............................................................................32

2.7.4 Finalizando un bucle con el estatuto “continue” ............................................................35

2.7.5 Utilización bucles con el estatuto “for”.........................................................................36

2.7.6 Diseñando un bucle con “for” o “while” .......................................................................37

2.8 Secuencias..................................................................................................................40

2.8.1 Cadenas...................................................................................................................40

2.8.2 Recorriendo una cadena mediante un bucle ..............................................................41

5
2.8.3 Partiendo una cadena ............................................................................................42

2.8.4 Las cadenas son inmutables ................................................................................43

2.8.5 Iterando y contando ..............................................................................................44

2.8.5 El operador “in” ....................................................................................................44

2.9 Glosario de términos ....................................................................................................45

2.10 Ejercicios de autoevaluación........................................................................................46

6
Iconografía

Para facilitar la lectura de este material de apoyo, se han utilizado íconos a lo largo del texto

con el propósito de destacar un contenido en específico. A continuación, se presenta cada

uno y se indica su significado:

Actividad audiovisual Atención Concepto

Propone actividades Se utiliza para llamar su Se emplea para definir un

relacionadas con la atención sobre algún punto concepto complejo o que el

exposición de material de singular peso para su estudiante debe dominar

audiovisual proceso de aprendizaje para comprender la lectura.

complementario

7
Al finalizar esta unidad de aprendizaje, la persona estudiante tendrá los

siguientes resultados de aprendizaje:

1. Describe diferentes tipos de datos utilizados en programación

explicando sus características y rangos de valores que aseguran la

eficiencia en la producción de datos en las tareas del campo técnico-

laboral en un contexto global.

2. Interpreta cómo se seleccionan y declaran variables según el tipo de

dato en la implementación de estructuras y programas, explicando
la importancia en la asignación de un tipo de dato correcto para la

manipulación de variables con información pertinente, confiable y

válida en un contexto global.
3. Utiliza tipos de datos adecuados para la declaración de variables en

la implementación de estructuras y programas, para la resolución de

operaciones y manipulaciones en un programa para la eficiencia en
las tareas del campo técnico-laboral en un contexto global.

4. Evalúa críticamente el uso y la selección de tipos de datos en la

implementación de estructuras y programas para optimizar la
manipulación de variables demostrando pensamiento crítico y

actitud de indagación para el planteamiento y la resolución de

problemas en un contexto global.

8
 Unidad 2: Tipos de datos

2.1 Tipos de datos en programación

En programación Python, existen varios tipos de datos básicos, por ejemplo:

el tipo entero (int), el tipo real (float), el tipo cadena o string (str), el tipo lógico (bool)
y estos tipos de datos básicos se construyen a partir de estructuras de datos más

pequeñas donde estas estructuras de datos (salvo el tipo None) almacenan

información.

Al operar con ellos, se generarán nuevas estructuras de datos con base a las
antiguas: por lo tanto, las estructuras de datos también se pueden denominar valores
y a las operaciones entre ellas también se les puede denominar valores. Las

estructuras de datos se llaman valores cuando se les denomina únicamente para

indicar su valor concreto, en cambio, en la mayoría de los casos se está refiriendo a
la forma en la que se han almacenado.

Conocer los tipos de datos, también llamados estructuras, nos permitirá

comprender con mayor precisión cómo se almacena la información de un programa
y cómo se comporta un programa al operar con esos datos. Además, el conocimiento

de estos conceptos nos servirá para aprender con mayor facilidad nuevos lenguajes
de programación, con independencia del lenguaje de programación que utilicemos
en estos apuntes.

Los aspectos que nos enfocarán en un lenguaje de programación son los

detalles concretos, como la lectura por teclado, la escritura en pantalla, la ejecución

de programas, las peculiaridades de la biblioteca estándar y las funciones y módulos

con los que vamos a trabajar.
A continuación, explicamos el uso básico de los tipos de datos:

9
 • Bool: Se utiliza para representar un valor de "verdadero" o "falso". Las

operaciones lógicas admiten las siguientes "operaciones": or, and, not.

• Cadenas de texto o caracteres: Son secuencias de caracteres (letras,
números, especiales, etc.).

• Números: Python permite trabajar con tres tipos de números o valores

numéricos: enteros, flotantes y complejos. Las operaciones numéricas

admiten los siguientes operadores numéricos: +, -, *, /, //, ** y %.

• Variables y tipo de dato: Una variable es un espacio o lugar en la memoria
de la computadora que se utiliza para almacenar temporalmente el valor

de una expresión o de un dato. La variable es un "palabra" o "nombre" que

nos permite acceder a un dato almacenado, sin tener que saber en qué
lugar exactamente se encuentra guardado este dato. A diferencia de otros

lenguajes de programación, en Python, no es necesario "declarar" el tipo

de dato que almacenará la variable para poder utilizarla. Python permite
que el tipo de dato sea definido de "manera dinámica" en tiempo de

ejecución.
Es importante saber que en el lenguaje de programación Python, como en
cualquier lenguaje de programación, existen los tipos de datos simples (números,

cadenas de caracteres y booleanos) y los tipos de datos compuestos (listas, tuplas y

diccionarios).
Una variable es un espacio o lugar en la memoria de la computadora que se

utiliza para almacenar temporalmente el valor de una expresión o de un dato. La

variable es un "palabra" o "nombre" que nos permite acceder a un dato almacenado,

sin tener que saber en qué lugar exactamente se encuentra guardado este dato. A
diferencia de otros lenguajes de programación, en Python, no es necesario "declarar"

10
el tipo de dato que almacenará la variable para poder utilizarla. Python permite que

el tipo de dato sea definido de "manera dinámica" en tiempo de ejecución.

A continuación, se describen los tipos de datos en Python y mediante un

ejemplo de cómo podemos declararlo y utilizarlo:

Tipos de datos en Python

Ejemplo Tipo de dato Descripción

x = "Soy estudiante de SIS" str String Cadena de caracteres

x= 20 int Entero Número entero

x = 20.5 float Flotante Número flotante

x= 1j complex Complejo Número complejo

x = ["apple", "banana", "cherry"] list Lista Lista que puede contener

elementos de diferentes

tipos de datos

x = ("apple", "banana", "cherry") tuple Tupla Tupla que puede contener

elementos de diferentes
tipos de datos

x = {"name" : "John", "age" : 36} dict Diccionario Permite registrar elementos

de diferentes tipos de datos

mediante especificando un
nombre de atributo

x = {"apple", "banana", "cherry"} set Conjunto Permite registrar elementos

de diferentes tipos de datos

11
 Consideremos que los programas funcionan con datos que pueden ser letras

o números. Ahora bien, dependiendo del valor de un dato así serán las operaciones
con que se manipulen estos datos.

Por otra parte, los valores pueden ser de diferentes tipos: los hay de tipo

entero, como el número 20, o de tipo hilera o cadena de caracteres (string), como la
expresión "Soy estudiante de SIS" como lo vemos en la tabla anterior. Estos últimos

se reconocen porque los caracteres aparecen entre comillas. También los hay de
tipo real o flotante y de tipo lógico. Un valor de tipo real o flotante tiene dos partes:
una entera y una decimal y un valor de tipo lógico tiene sólo uno de dos valores

"True" y "False".

2.2 Introducción a las funciones

Desde el contexto de programación, una función es una secuencia de

sentencias que realizan una operación y que reciben un nombre. Cuando se define

una función, se especifica el nombre y la secuencia de sentencias. Más adelante, se

puede “llamar” a la función por ese nombre. Ya hemos visto un ejemplo de una
llamada a una función:

>>> type(32)
<class 'int'>
El nombre de la función es type. La expresión entre paréntesis recibe el

nombre de argumento de la función. El argumento es un valor o variable que se pasa

a la función como parámetro de entrada. El resultado de la función type es el tipo
del argumento. Es habitual decir que una función “toma” (o recibe) un argumento

y “retorna” (o devuelve) un resultado. El resultado se llama valor de retorno.

12
 Python proporciona un número importante de funciones internas, que

pueden ser usadas sin necesidad de tener que definirlas previamente. Los
creadores de Python han escrito un conjunto de funciones para resolver problemas
comunes y las han incluido en Python para que las podamos utilizar.

Las funciones “max” y “min” nos darán respectivamente el valor mayor y

menor de una lista:

>>> max('¡Hola, mundo!')

’u’
>>> min('¡Hola, mundo!')
’’
>>>

La función max nos dice cuál es el “carácter más grande” de la cadena (que
resulta ser la letra “u”), mientras que la función min nos muestra el carácter más
pequeño (que en ese caso es un espacio).

Otra función interna muy común es len, que nos dice cuántos elementos hay
en su argumento. Si el argumento de len es una cadena, nos devuelve el número de
caracteres que hay en la cadena.

>>> len('Hola, mundo')

11

Estas funciones no se limitan a buscar en cadenas. Pueden operar con

cualquier conjunto de valores, como veremos en los siguientes capítulos.

Se deben tratar los nombres de las funciones internas como si fueran

palabras reservadas (es decir, evita usar “max” como nombre para una variable).

13
 2.2.1 Funciones para convertir tipos de datos

En programación Python proporciona funciones internas que

convierten valores de un tipo a otro. La función int() toma cualquier valor y
lo convierte en un entero, si puede, o se queja si no puede:

• La función int() toma cualquier valor y lo convierte en un

entero, si puede, o se queja si no puede:

>>> int('32') 32
>>> int('Hola')

ValueError: invalid literal for int() with base 10: 'Hola'

int() puede convertir valores en punto flotante a enteros, pero no los

redondea; simplemente corta y descarta la parte decimal:

>>> int(3.99999)
3
>>> int(-2.3)
-2

• La función float() convierte enteros y cadenas en números de

punto flotante:

>>> float(32) 32.0

>>> float('3.14159') 3.14159

• Finalmente, la función str() convierte su argumento en una

cadena:

14
 >>> str(32)
’32’
>>> str(3.14159)
’3.14159’

2.2.1 Funciones matemáticas

Python tiene un módulo matemático (math), que proporciona la

mayoría de las funciones matemáticas habituales. Antes de que podamos

utilizar el módulo, debemos importarlo:

>>> import math

Esta sentencia crea un objeto módulo llamado math. Si se imprime el

objeto módulo, se obtiene cierta información sobre él:

>>> print(math)
<module 'math' (built-in)>

El objeto módulo contiene las funciones y variables definidas en el

módulo. Para acceder a una de esas funciones, es necesario especificar el

nombre del módulo y el nombre de la función, separados por un punto (“.”)

>>> relacion = int_senal / int_ruido

>>> decibelios = 10 * math.log10(relacion)

>>> radianes = 0.7

>>> altura = math.sin(radianes)

El primer ejemplo calcula el logaritmo en base 10 de la relación señal

y ruido. El módulo math también proporciona una función llamada log que
calcula logaritmos en base e.

15
 El segundo ejemplo calcula el seno de la variable radianes. El nombre

de la variable es una pista de que sin y las otras funciones trigonométricas

(cos, tan, etc.) toman argumentos en radianes. Para convertir de grados a
radianes, hay que dividir por 360 y multiplicar por 2π:

>>> grados = 45
>>> radianes = grados / 360.0 * 2 * math.pi
>>> math.sin(radianes)

0.7071067811865476

La expresión math.pi toma la variable pi del módulo math. El valor

de esa variable es una aproximación de π, con una precisión de unos 15

dígitos.

Si sabes de trigonometría, puedes comprobar el resultado anterior,

comparándolo con la raíz cuadrada de dos dividida por dos:

>>> math.sqrt(2) / 2.0

0.7071067811865476

2.2.3 Función para generación de números aleatorios

Los números aleatorios en programación no son verdaderamente

aleatorios, ya que son generados por una operación determinista, pero si

sólo nos fijamos en los números resulta casi imposible distinguirlos de los
aleatorios de verdad.

En Python el módulo random proporciona funciones que generan

números pseudoaleatorios (a los que simplemente llamaremos “aleatorios”
de ahora en adelante).

16
 La función random devuelve un número flotante aleatorio entre 0.0 y

1.0 (incluyendo 0.0, pero no 1.0). Cada vez que se llama a random, se obtiene
el número siguiente de una larga serie. Para ver un ejemplo, ejecuta este
bucle:

import random
for i in range(10):
x = random.random()
print(x)

Este programa produce la siguiente lista de 10 números aleatorios

entre 0.0 y hasta (pero no incluyendo) 1.0.

0.8727446792654728
0.4598556497960913
0.4048473074742627
0.2550815487809597
0.03705375356236451
0.36325978550465887
0.9446298521712144
0.7254891408627904
0.4068525467493834
0.9336288569173679

2.2.4 Repaso de operadores matemáticos

Los operadores matemáticos son signos especiales que representan
cálculos como la suma y la multiplicación. Los valores a los que se aplican

estos operadores se conocen como operandos. Cuando el nombre de una

variable aparece en el lugar de un operando, este debe ser reemplazado por

un valor antes de realizar la operación.

La siguiente tabla resume los operadores matemáticos de Python:

17
 Operación Resultado Operación Resultado
x+z suma de x y z x-z diferencia de x y z
x*z producto x y z x/z cociente x y z
x // z cociente entero x y z x ** z x a la potencia de z
x%z residuo x y z = -x x negado

Los símbolos +, -, /, y el uso de paréntesis para agrupar tienen el mismo

significado en Python que en matemática. El asterisco (*) es el símbolo de la
multiplicación, "//" es el símbolo de la división entera y dos asteriscos ( ** ) es el

símbolo de la exponenciación.

Un operador muy útil en operaciones matemáticas es el llamado módulo,

cuyo símbolo en Python es "%". Este operador permite obtener el residuo de dividir

el primer operando entre el segundo.

En el ejemplo siguiente se utiliza el operador // para saber el resultado entero

de dividir 7 entre 3. En el ejemplo con el operador % se desea averiguar si el número

7 es divisible entre 3. Si el resultado es 0, sí es divisible (en este caso no lo es, pues el
resultado es 1).

>>> cociente = 7 // 3
print (cociente)
2
>>> residuo = 7 % 3
>>> print (residuo)
1

Por otra parte, recordemos que las expresiones son una combinación de
valores, variables y operadores. Cuando se coloca una expresión en la línea de

comandos, el intérprete la evalúa y muestra el resultado. Evaluar una expresión no

es lo mismo que imprimir un valor. Un ejemplo de una expresión es 2 + 3

18
 Como se aprecia en los siguientes ejemplos, cuando Python despliega el valor

de una expresión, usa el mismo formato que se usa para ingresar un valor. Cuando
se introduce una cadena, esta debe ir entre comillas. La función print despliega el
valor de la expresión, que en este caso es el contenido de la cadena.

>>> n=2
>>> n
2
>>>1+1
2
>>> 17
17
>>> mensaje = "Hola"
>>> print (mensaje)
Hola

Los lenguajes de programación pueden tomar pequeños bloques de

instrucciones y unirlas (componerlos) en una nueva. Por ejemplo, multiplicar, sumar

e imprimir números, son dos instrucciones que se pueden componer en una sola
instrucción.

>>> min=30

>>> hora = 12

>>> print ("Núm minutos:", hora*60+min)

Núm minutos: 750

>>> porcentaje = (min * 100) / 60

>>> print (17 +3, porcentaje)

20 50.0

19
 La siguiente composición es ilegal porque al lado izquierdo de un estatuto de

asignación sólo puede ir el nombre de una variable, y no una expresión:

>>> min+1=hora
SyntaxError: can't assign to operator (<pyshell#55>, line 1)
>>>

Cuando en una expresión aparece más de un operador, el orden de

evaluación depende de las reglas de precedencia. En Python, las operaciones
matemáticas siguen las mismas reglas de precedencia que se aplican en matemáticas

(de izquierda a derecha). Por ejemplo, "2 *3-1" es igual a 5; "2/3-1" es igual a -1 y no
a 1.

2.3 Creación de funciones

Además de permitir usar funciones que ya se habían creado

previamente, Python permite crear nuevas funciones con el fin de resolver
problemas particulares.

Una función debe estar definida antes de usarse. Esta operación se

especifica mediante una definición de función. La sintaxis para definir una
función es la siguiente.

def nombreFuncion (lista_parametros):

…..estatutos

En Python, las funciones, lo mismo que las variables, deben tener

nombres válidos. Los estatutos que se encuentran dentro de la función deben

ir identados (tabulados) desde el margen izquierdo. La tabulación le indica

al intérprete cuál instrucción pertenece a una función y cuál no.

20
 En el ejemplo siguiente se define una función llamada imprime, que

recibe un parámetro llamado mensaje. Python diferencia las instrucciones

de la función imprime de las del programa principal, gracias a la tabulación.
De esta forma, la función print que se encuentra dentro de la función, debe

ir tabulada. Luego, en el programa principal, se ejecuta dos veces la función

imprime con diferentes valores.

# Función que recibe un mensaje y lo despliega en pantalla

def imprime (mensaje):
print (mensaje)
# Programa principal
imprime ("Primer línea!")
imprime ("Segunda línea!")

Antes de escribir una función hay que tomar varias decisiones:

1. ¿Qué nombre ponerle? Debe ser un nombre que tenga sentido y que
describa el propósito de la función.

2. ¿Qué valor o valores se le deberán dar a la función para que haga su

trabajo?
3. ¿Qué deberá hacer la función? ¿Cuál es su propósito?

4. ¿Qué valor deberá devolver la función? Se debe considerar el tipo y

el valor que debe devolver, una vez hecho su trabajo.

Es importante considerar que el orden en que se ejecutan los estatutos

se conoce como flujo de ejecución. La ejecución siempre inicia con la primera
instrucción del programa que no esté tabulada. Las instrucciones se ejecutan,

una a la vez, de arriba hacia abajo. La definición de funciones no altera el

flujo de ejecución de un programa.

21
 Las funciones solo se ejecutan cuando son llamadas en una

instrucción. Estas llamadas son como desvíos dentro del flujo de ejecución.
En estos casos, en lugar de ejecutar la siguiente instrucción, el flujo salta a la
primera línea de la función invocada, ejecuta todos sus estatutos y luego

regresa a la siguiente instrucción desde donde fue invocada.

2.3.1 Creación de variables dentro de funciones

Una variable local es aquella que se crea dentro de una función, que existe

solamente dentro de esa función y que no podrá ser usada fuera de ella. Los
parámetros se tratan como variables locales:

# función que recibe dos números y los suma

def suma (n1, n2):

resultado = n1 + n2
imprime (resultado)

# función que recibe un mensaje y lo despliega

def imprime (mensaje):

print (mensaje)

# Programa principal

num1=2
num2=3
suma (num1, num2)
imprime (resultado)

En el ejemplo anterior vemos cómo la función suma toma dos argumentos,

los suma y luego invoca la función imprime para mostrar el resultado. Cuando la

22
función suma finaliza su ejecución, las variables resultado, n1 y n2 se destruyen. Si

se tratan de usar en el programa principal, se generará el siguiente error:

Traceback (most recent call last):

line 17, in <module> print (resultado)
NameError: name "resultado" is not defined

Una variable global es aquella que se crea utilizando la palabra clave global a
la hora de inicializarla. A diferencia de una variable local, la variable global se

conoce en todo el programa, y puede ser usada en cualquier parte de este.

# Ejemplo A: función que crea una variable local y la imprime

def func1 ():
a=4
print (a)

global a
a=1
func1 ()
print (a)

#Ejemplo B: función que crea una variable global y la imprime

def func1 ():
global a
a=4
print (a)
a=1
func1 ()
print (a)

En el ejemplo “A” se crean dos variables de nombre a, una en la función de

nombre func1, y otra variable global, con el mismo nombre. La variable global

almacena el valor de 1 y la local el valor de 4. El resultado de ejecutar las

instrucciones es 4 y 1.

23
 En el ejemplo “B” se crea una sola variable de nombre a, que se declara como

global en la función func1. La variable global almacena inicialmente el valor de 1 y

luego en la función adquiere el valor de 4. El resultado de ejecutar las instrucciones
es 4 y 4.

2.4 Uso del estatuto “return”

El estatuto “return” cumple dos funciones: primero finaliza inmediatamente

la ejecución de la función y, segundo, permite devolver el valor que se produce al
ejecutar una función. Si no se produce ningún valor, el estatuto devuelve el valor

None.
En el siguiente ejemplo, se define una función llamada cuadrado, que recibe
un parámetro de nombre x. Lo que devuelve es el valor resultante de multiplicar x

por sí misma.

# Función que retorna el cuadrado de un número

def cuadrado (x):
resultado = x * x
return resultado
# Programa principal
a = int (input ("Introduzca un valor numérico entero:"))
b = cuadrado (a)
print ("El cuadrado de ", a, "es", b)

En el programa principal del ejemplo anterior, se pide al usuario que digite

un número entero. Este valor se almacena en la variable “a”; luego se invoca la
función cuando y se le envía el valor recibido. La función “cuadrado” multiplica el

valor recibido por el mismo y devuelve el resultado del cálculo. Este resultado se
almacena en la variable “b” Por último, se imprimen los valores de a y b.

Una función podría tener varios estatutos de return, pero solo uno de ellos se

24
ejecutará. Tan pronto se ejecute, la función se dará por terminada. A continuación:

# Función que recibe un número y retorna su valor absoluto

def valorAbs (x):
ifx < 0:
retum -x
else:
return x

# Programa principal
a=5
res = valorAbs (a)
print ("El valor absoluto de " + str(a) +"es ", res)
b =- 10
print ("El valor absoluto de "+ str(b) +"es ", valorAbs (b))

En este ejemplo se define una función llamada valorAbs, que recibe un

parámetro de nombre x. Se observa que la función tiene dos estatutos return, de los
cuales solo uno se ejecutará según sea el resultado del condicional i/x < 0.

Si al ejecutar una función, no se cumple ninguna condición, la función podría

finalizar sin ejecutar el estatuto return. En estos casos, el valor de retorno es un valor
especial llamado None. El valor de retorno se puede usar directamente en una

instrucción o se puede asignar a una variable, como se muestra a continuación.

>>> import math

>>> resultado = math.sqrt (9)
>>> print (resultado, math.sqrt (25))

En el ejemplo anterior, se imprime el resultado de obtener la raíz cuadrada

(sqrt) de 9 y de 25. En el primer caso, el argumento es 9 y el resultado que devuelve

la función es 3. Este valor se almacena en la variable resultado. En el segundo, el

25
argumento es 25, y el resultado es 5. Este valor no se almacena en ninguna variable,

sino que solamente se imprime.

2.5 Uso de la función Lambda

Python tiene otra forma de crear funciones, las llamadas funciones lambda. Para ello
se utiliza la palabra reservada lambda, que sirve para crear funciones rápidamente

con el fin de hacer algún cálculo que requiera únicamente de una pequeña operación
o comprobación.

En el siguiente ejemplo se muestran dos funciones de nombre “función” y

“funcion2”. El resultado de ejecutar cualquiera de las dos funciones es el mismo.

#Creación de función con “def” que retoma el producto de x*y

def funcion (x, y):

return x* y

#Creación de función lambda que retoma el producto de x*y

funcion2 = lambda x, y : x * y

#Ejecución de funciones que realizan la misma operación e devuelven el mismo

resultado
print (funcion (2,3)) #Función “def”
print (funcion2 (2,3)) #Función “lambda”

Toda función lambda puede expresarse como una función convencional

(pero no toda función convencional puede expresarse como una función lambda).

26
 2.6 Aspectos a considerar el desarrollo de un programa

Cuando se desarrollan programas, es conveniente usar una técnica llamad

desarrollo incremental, que consiste en escribir y probar pequeñas cantidades de

código a la vez. Cuando se está seguro de que estas funciones trabajan

correctamente, se agregan más funciones y se vuelven a probar todas juntas.

Los aspectos clave de este proceso son los siguientes:

• Iniciar con un programa que trabaje y que se le puedan hacer
pequeños cambios de forma paulatina. De esta manera, si hay un

error en cualquier punto, se sabrá exactamente dónde está.

• Use variables temporales para mantener valores intermedios, de
manera que en cualquier momento se pueda consultar su valor.

Por ejemplo, supóngase que se quiere encontrar la distancia entre dos

puntos dados por las coordenadas (x1 , y1 ) y (x2 , y2 ), según el teorema de Pitágoras,
supongamos que la distancia es denominada por “D”:

𝐷 = √(𝑥2 − 𝑥1) 2 + (𝑦2 − 𝑦1) 2

Paso 1.

El primer paso es considerar que debe haber una función distancia que recibe

entradas (parámetros) y que devuelve una salida (un valor de retomo). En este caso,
los dos puntos dados por las coordenadas (x 1 , y1 ) y (x2 , y2 ), son las entradas, y el valor
de retorno es la distancia y su tipo será de tipo flotante.

27
 Luego, se muestra cómo podría escribirse esa función. Obviamente esta

función no calcula la distancia, solo devuelve 0, pero es sintácticamente correcta y

se podrá ejecutar. Esto significa que se puede probar antes de complicarla más.

# función que recibe cuatro coordenadas y retoma la distancia

def distancia (x1, ×2, y1, y2):
return 0.0

# programa principal
dist = distancia (1, 4, 2, 6)
print (dist)

Paso 2.

El siguiente paso es encontrar las diferencias entre (x 2 – y1 ) y (y2 – y1 ), estos

valores se almacenarán en variables temporales llamadas "dx" y "dy", que se

desplegarán en pantalla:

#función que recibe cuatro coordenadas y retorna la distancia

def distancia (x1, x2, y1, y2):
dx = x2 - x1
dy = y2 - y1
print("dx = ", dx, " dy= ", dy)
return 0.0

# programa principal
dist = distancia (1, 4, 2, 6)
print(dist)

Cuando se prueba una función, es conveniente saber el resultado que deberá

producir según los valores de los parámetros establecidos. En el ejemplo anterior, se

seleccionaron los valores 1, 4, 2, y 6 porque la distancia horizontal es 3, y la vertical

28
es 4. Si la función trabaja correctamente, los resultados mostrados deberán ser 3 4. Si

no, habrá que revisar el código para encontrar el error.

Cabe señalar que algunas instrucciones print() se incluyen de forma temporal

como parte de las pruebas que realizaremos al código y son una especie de “cascara”

para verificar que el programa se ejecute correctamente y deberán ser eliminadas

posteriormente.

Paso 3.

Por último, se calcula la suma de los cuadrados de los valores almacenados

en las variables dx y dy. Se importa el módulo de matemáticas para aplicar la

función de raíz cuadrada y se calcula el resultado.

# función que recibe cuatro coordenadas y retorna la distancia

import math
def distancia (x1, x2, y1, y2):
dx = x2 - x1
dy = y2 - y1
distCuad = dx ** 2 + dy ** 2
print ("dx =", dx, " dy=", dy, " distCuad=", distCuad)
res = math.sqrt (distCuad)
return res

# programa principal
dist = distancia (1, 4, 2, 6)
print (dist)

En este ejemplo el resultado es 5, que es el valor que corresponde a la

hipotenusa de un triángulo 3-4-5. Si el resultado es correcto, ya finalizó el desarrollo
del programa. De lo contrario, habrá que buscar la razón de por qué no se obtiene el

resultado esperado.

29
 2.7 Iteración
2.7.1 Actualizando una variable

Uno de los usos habituales de las sentencias de asignación consiste en

realizar una actualización sobre una variable en la cual el valor nuevo de esa
variable depende del antiguo.

>>> x = x + 1

Esto quiere decir “‘toma el valor actual de x, añádele 1, y luego

actualiza x con el nuevo valor”. Si intentas actualizar una variable que no
existe, obtendrás un error, ya que Python evalúa el lado derecho antes de
asignar el valor a x:

>>> x = x + 1
NameError: name 'x' is not defined

Antes de que puedas actualizar una variable, debes inicializarla,

normalmente me- diante una simple asignación:

>>> x = 0
>>> x = x + 1

Actualizar una variable añadiéndole 1 se denomina incrementar;

restarle 1 recibe el nombre de decrementar (o disminuir).

30
 2.7.2 La sentencia “while”

Las computadoras se suelen utilizar a menudo para automatizar

tareas repetitivas. Repetir tareas idénticas o muy similares sin cometer

errores es algo que a las máquinas se les da bien y en cambio a las personas
no. Como las iteraciones resultan tan habituales, Python proporciona varias
características en su lenguaje para hacerlas más sencillas.

Una forma de iteración en Python es la sentencia “while”. He aquí un

programa sencillo que cuenta hacia atrás desde cinco y luego dice
“¡Despegue!”.

n= 5
while n > 0:
print(n)
n= n-1
print('¡Despegue!')

Casi se puede leer la sentencia while como si estuviera escrita en

inglés. Significa, “Mientras n sea mayor que 0, muestra el valor de n y luego

reduce el valor de n en 1 unidad. Cuando llegues a 0, sal de la sentencia

while y muestra la palabra ¡Despegue!

Éste es el flujo de ejecución de la sentencia while, explicado de un modo más

formal:

a) Se evalúa la condición, obteniendo Verdadero or Falso.

b) Si la condición es falsa, se sale de la sentencia while y se continúa la

ejecución en la siguiente sentencia.

31
 c) Si la condición es verdadera, se ejecuta el cuerpo del while y luego se

vuelve al paso 1.

Este tipo de flujo recibe el nombre de bucle, ya que el tercer paso

enlaza de nuevo con el primero. Cada vez que se ejecuta el cuerpo del bucle
se dice que realizamos una iteración. Para el bucle anterior, podríamos decir
que “ha tenido cinco iteraciones”, lo que significa que el cuerpo del bucle se

ha ejecutado cinco veces.

El cuerpo del bucle debe cambiar el valor de una o más variables, de
modo que la condición pueda en algún momento evaluarse como falsa y el

bucle termine. La variable que cambia cada vez que el bucle se ejecuta y
controla cuándo termina éste, recibe el nombre de variable de iteración. Si
no hay variable de iteración, el bucle se repetirá para siempre, resultando así

un bucle infinito.

2.7.3 Bucles infinitos y estatuto “break”

Una fuente de diversión sin fin para los programadores es la

constatación de que las instrucciones del champú: “Enjabone, aclare, repita”,
son un bucle infinito, ya que no hay una variable de iteración que diga

cuántas veces debe ejecutarse el proceso.

En el caso de una cuenta atrás, podemos verificar que el bucle

termina, ya que sabemos que el valor de n es finito, y podemos ver que ese

valor se va haciendo más pequeño cada vez que se repite el bucle, de modo
que en algún momento llegará a 0. Otras veces un bucle es obviamente
infinito, porque no tiene ninguna variable de iteración.

32
 A veces no se sabe si hay que terminar un bucle hasta que se ha

recorrido la mitad del cuerpo del mismo. En ese caso se puede crear un bucle
infinito a propósito y usar la sentencia break para salir de él cuando se desee.
El bucle siguiente es, obviamente, un bucle infinito, porque la

expresión lógica de la sentencia while es simplemente la constante lógica

True (verdadero):

n = 10
while True:
print(n, end=' ')
n= n-1
print('¡Terminado!')

Si cometes el error de ejecutar este código, aprenderás rápidamente

cómo detener un proceso de Python bloqueado en el sistema, o tendrás que

localizar dónde se encuentra el botón de apagado de tu equipo. Este

programa funcionará para siempre, o hasta que la batería del equipo se
termine, ya que la expresión lógica al principio del bucle es siempre cierta,

en virtud del hecho de que esa expresión es precisamente el valor constante

True.

A pesar de que en este caso se trata de un bucle infinito inútil, se

puede usar ese diseño para construir bucles útiles, siempre que se tenga la
precaución de añadir código en el cuerpo del bucle para salir explícitamente,
usando break cuando se haya alcanzado la condición de salida.

Por ejemplo, supón que quieres recoger entradas de texto del usuario
hasta que éste escriba fin. Podrías escribir:

33
while True:
linea = input('> ')
if linea == 'fin':
break
print(linea)
print('¡Terminado!')

La condición del bucle es True, lo cual es verdadero siempre, así que

el bucle se repetirá hasta que se ejecute la sentencia break.

Cada vez que se entre en el bucle, se pedirá una entrada al usuario. Si

el usuario escribe fin, la sentencia break hará que se salga del bucle. En
cualquier otro caso, el programa repetirá cualquier cosa que el usuario

escriba y volverá al principio del bucle. Éste es un ejemplo de su

funcionamiento:

> hola a todos

hola a todos
> he terminado
he terminado
> fin
¡Terminado!

Este modo de escribir bucles while es habitual, ya que así se puede

comprobar la condición en cualquier punto del bucle (no sólo al principio),

y se puede expresar la condición de parada afirmativamente (“detente

cuando ocurra. . . ”), en vez de tener que hacerlo con lógica negativa (“sigu e

haciéndolo hasta que ocurra. . . ”).

34
 2.7.4 Finalizando un bucle con el estatuto “continue”

Algunas veces, estando dentro de un bucle se necesita terminar con

la iteración actual y saltar a la siguiente de forma inmediata. En ese caso se

puede utilizar la sentencia continue para pasar a la siguiente iteración sin

terminar la ejecución del cuerpo del bucle para la actual.

A continuación, se muestra un ejemplo de un bucle que repite lo que

recibe como entrada hasta que el usuario escribe “fin”, pero trata las líneas

que empiezan por el carácter almohadilla como líneas que no deben

mostrarse en pantalla (algo parecido a lo que hace Python con los

comentarios).

while True:
linea = input('> ')
if linea[0] == '#' :
continue
if linea == 'fin':
break
print(linea)
print('¡Terminado!')

Por ejemplo, una ejecución de ejemplo de ese nuevo programa con la

sentencia continue añadida:

> hola a todos

hola a todos
> # no imprimas esto
> ¡imprime esto!
¡imprime esto!
> fin
¡Terminado!
35
 Todas las líneas se imprimen en pantalla, excepto la que comienza con

el símbolo de almohadilla, ya que en ese caso se ejecuta continue, finaliza la

iteración actual y salta de vuelta a la sentencia while para comenzar la
siguiente iteración, de modo que se omite la sentencia print.

2.7.5 Utilización bucles con el estatuto “for”

A veces se desea repetir un bucle a través de un conjunto de cosas,

como una lista de palabras, las líneas de un archivo, o una lista de números.
Cuando se tiene una lista de cosas para recorrer, se puede construir un bucle

definido usando una sentencia for. A la sentencia while se la llama un bucle

indefinido, porque simplemente se repite hasta que cierta condición se hace
Falsa, mientras que el bucle for se repite a través de un conjunto conocido

de elementos, de modo que ejecuta tantas iteraciones como elementos hay

en el conjunto.

La sintaxis de un bucle for es similar a la del bucle while, en ella hay

una sentencia for y un cuerpo que se repite:

amigos = ['Joseph', 'Glenn', 'Sally']

for amigo in amigos:
print('Feliz año nuevo:', amigo)
print('¡Terminado!')

En términos de Python, la variable amigos es una lista1 de tres

cadenas y el bucle for se mueve recorriendo la lista y ejecuta su cuerpo una

vez para cada una de las tres cadenas en la lista, produciendo esta salida:

36
Feliz año nuevo: Joseph
Feliz año nuevo: Glenn
Feliz año nuevo: Sally
¡Terminado!

La traducción de este bucle for al español no es tan directa como en el

caso del while, pero si piensas en los amigos como un conjunto, sería algo
así como: “Ejecuta las sentencias en el cuerpo del bucle una vez para (for)

cada amigo que esté en (in) el conjunto llamado amigos.”

Revisando el bucle “for”, “for” e “in” son palabras reservadas de
Python, mientras que amigo y amigos son variables:

amigos = ['Joseph', 'Glenn', 'Sally']

for amigo in amigos:
print("Feliz año nuevo::", amigo)

En concreto, amigo es la variable de iteración para el bucle for. La

variable amigo cambia para cada iteración del bucle y controla cuándo se

termina el bucle for. La variable de iteración se desplaza sucesivamente a

través de las tres cadenas almacenadas en la variable amigos.

2.7.6 Diseñando un bucle con “for” o “while”

A menudo se usa un bucle for o while para movernos a través de una

lista de elementos o el contenido de un archivo y se busca algo, como el valor

más grande o el más pequeño de los datos que estamos revisando.

Los bucles generalmente se construyen así:
a) Se inicializan una o más variables antes de que el bucle comience

37
 b) Se realiza alguna operación con cada elemento en el cuerpo del bucle,
posiblemente cambiando las variables dentro de ese cuerpo.
c) Se revisan las variables resultantes cuando el bucle se completa.

Usaremos ahora una lista de números para demostrar los conceptos

y construcción de estos diseños de bucles. Por ejemplo, para contar el

número de elementos en una lista, podemos escribir el siguiente bucle for:

contador = 0
for valor in [3, 41, 12, 9, 74, 15]:
contador = contador + 1
print('Numeros de elementos: ', contador)

Ajustamos la variable “contador” del código a cero antes de que el

bucle comience, después escribimos un bucle “for” para movernos a través

de la lista de números. Nuestra variable de iteración se llama valor, y dado

que no usamos valor dentro del bucle, lo único que hace es controlar el bucle
y hacer que el cuerpo del mismo sea ejecutado una vez para cada uno de los

valores de la lista.

En el cuerpo del bucle, añadimos 1 al valor actual de contador para

cada uno de los valores de la lista. Mientras el bucle se está ejecutando, el

valor de contador es la cantidad de valores que se hayan visto “hasta ese

momento”.

Una vez el bucle se completa, el valor de contador es el número total

de elementos. El número total “cae en nuestro poder” al final del bucle. Se

construye el bucle de modo que obtengamos lo que queremos cuando éste

termina.

38
 Otro bucle similar, que calcula el total de un conjunto de números, se

muestra a continuación:

total = 0
for valor in [3, 41, 12, 9, 74, 15]:
total = total + valor
print('Total: ', total)

En este bucle, sí utilizamos la variable de iteración. En vez de añadir

simplemente uno a contador como en el bucle previo, ahora durante cada

iteración del bucle añadimos el número actual (3, 41, 12, etc.) al total en ese
momento. Si piensas en la variable total, ésta contiene la “suma parcial de
valores hasta ese momento”.

Así que antes de que el bucle comience, total es cero, porque aún no
se ha examinado ningún valor. Durante el bucle, total es la suma parcial, y
al final del bucle, total es la suma total definitiva de todos los valores de la

lista. Cuando el bucle se ejecuta, total acumula la suma de los elementos;

una variable que se usa de este modo recibe a veces el nombre de
acumulador.

Ni el bucle que cuenta los elementos ni el que los suma resultan

particularmente útiles en la práctica, dado que existen las funciones internas
len() y sum() que cuentan el número de elementos de una lista y el total de

elementos en la misma respectivamente.

39
 2.8 Secuencias

2.8.1 Cadenas

Una cadena es una secuencia de caracteres. Puedes acceder a los caracteres de

uno en uno con el operador corchete:

>>> fruta = 'banana'

>>> letra = fruta[1]

La segunda sentencia extrae el carácter en la posición del índice 1 de la

variable fruta y la asigna a la variable letra. La expresión en los corchetes es llamada

índice. El índice indica qué carácter de la secuencia quieres (de ahí el nombre).
Pero podrías no obtener lo que esperas:

>>> print(letra)
a

Para la mayoría de las personas, la primera letra de “banana” es “b”, no “a”.

Pero en Python, el índice es un desfase desde el inicio de la cadena, y el desfase de
la primera letra es cero.

>>> letra = fruta[0]

>>> print(letra) b

Así que “b” es la letra 0 (“cero”) de “banana”, “a” es la letra con índice 1, y
“n” es la que tiene índice 2, etc. Puedes usar cualquier expresión, incluyendo
variables y operadores, como un índice, pero el valor del índice tiene que ser un

entero. De otro modo obtendrás:

40
>>> letra = fruta[1.5]
TypeError: string indices must be integers

En la tabla siguiente veremos la posición de la indexación positiva y la

indexación negativa

Cadena b a n a n a
Índice positivo [0] [1] [2] [3] [4] [5]
Índice negativo [-6] [-5] [-4] [-3] [-2] [-1]

2.8.2 Recorriendo una cadena mediante un bucle

Muchos de los cálculos requieren procesar una cadena carácter por carácter.

Frecuentemente empiezan desde el inicio, seleccionando cada carácter presente,

haciendo algo con él, y continuando hasta el final. Este patrón de procesamiento es
llamado un recorrido. Una manera de escribir un recorrido es con un bucle while:

indice = 0
while indice < len(fruta):
letra = fruta[indice]
print(letra)
indice = indice + 1

Este bucle recorre la cadena e imprime cada letra en una línea cada una. La
condición del bucle es indice < len(fruta), así que cuando índice es igual al tamaño
de la cadena, la condición es falsa, y el código del bucle no se ejecuta. El último

carácter accedido es el que tiene el índice len(fruta)-1, el cual es el último carácter en

la cadena.

Otra forma de escribir un recorrido es con un bucle for:

41
>>> for caracter in fruta:
print(carácter)

Cada vez que iteramos el bucle, el siguiente carácter en la cadena es asignado

a la variable carácter. El ciclo continúa hasta que no quedan caracteres.

2.8.3 Partiendo una cadena

Un segmento de una cadena es llamado rebanado. Seleccionar un rebanado

es similar a seleccionar un carácter:

>>> s = 'Monty Python'

>>> print(s[0:5]) Monty
>>> print(s[6:12]) Python

Si omites el primer índice (antes de los dos puntos), el rebanado comienza

desde el inicio de la cadena. Si omites el segundo índice, el rebanado va hasta el final

de la cadena:

>>> fruta = 'banana'

>>> fruta[:3]
’ban’
>>> fruta[3:]
’ana’

Si el primer índice es mayor que o igual que el segundo, el resultado es una

cadena vacía, representado por dos comillas:

42
>>> fruta = 'banana'
>>> fruta[3:3]

Una cadena vacía no contiene caracteres y tiene un tamaño de 0, pero fuera

de esto es lo mismo que cualquier otra cadena.

2.8.4 Las cadenas son inmutables

Puede ser tentador utilizar el operador [] en el lado izquierdo de una

asignación, con la intención de cambiar un carácter en una cadena. Por ejemplo:

>>> saludo = 'Hola, mundo!'

>>> saludo[0] = 'H'

TypeError: 'str' object does not support item assignment

El “objeto” en este caso es la cadena y el “ítem” es el carácter que tratamos de

asignar. Por ahora, un objeto es la misma cosa que un valor, pero vamos a redefinir
esa definición después. Un ítem es uno de los valores en una secuencia.
La razón por la cual ocurre el error es que las cadenas son inmutables, lo cual

significa que no puedes modificar una cadena existente. Lo mejor que puedes hacer
es crear una nueva cadena que sea una variación de la original:

>>> saludo = 'Hola, mundo!'

>>> nuevo_saludo = 'H' + saludo[1:]
>>> print(nuevo_saludo)
Hola, mundo!

43
 Este ejemplo concatena una nueva letra a una parte de saludo. Esto no tiene

efecto sobre la cadena original.

2.8.5 Iterando y contando

El siguiente programa cuenta el número de veces que la letra “a” aparece en

una cadena:

palabra = 'banana'
contador = 0
for letra in palabra:
if letra == 'a':
contador = contador + 1
print(contador)

Este programa demuestra otro patrón de computación llamado contador. La

variable “contador” es inicializada a 0 y después se incrementa cada vez que una

“a” es encontrada.

2.8.5 El operador “in”

La palabra in es un operador booleano que toma dos cadenas y regresa True

si la primera cadena aparece como una subcadena de la segunda:

>>> 'a' in 'banana'

True
>>> 'semilla' in 'banana'
False

44
 2.9 Glosario de términos

• Algoritmo: Un proceso general para resolver una categoría de problemas.

• Argumento: Un valor proporcionado a una función cuando ésta es llamada.
Ese valor se asigna al parámetro correspondiente en la función.

• Cabecera: La primera línea de una definición de función.

• Cuerpo: La secuencia de sentencias dentro de la definición de una función.
• Definición de función: Una sentencia que crea una función nueva,

especificando su nombre, parámetros, y las sentencias que ejecuta.

• Función: Una secuencia de sentencias con un nombre que realizan alguna
operación útil. Las funciones pueden tomar argumentos o no, y pueden

producir un resultado o no.

• Flujo de ejecución: El orden en el cual se ejecutan las sentencias durante el
funcionamiento de un programa.

• Llamada a función Una sentencia que ejecuta una función. Consiste en el

nombre de la función seguido por una lista de argumentos.

• Objeto función: Un valor creado por una definición de función. El nombre

de la función es una variable que se refiere al objeto función.
• Objeto módulo: Un valor creado por una sentencia import, que proporciona

acceso a los datos y código definidos en un módulo.

• Parámetro Un nombre usado dentro de una función para referirse al valor
pasado como argumento.

• Sentencia import: Una sentencia que lee un archivo módulo y crea un objeto
módulo.
• Valor de retorno: El resultado de una función. Si una llamada a una función

es usada como una expresión, el valor de retorno es el valor de la expresión.

45
 2.10 Ejercicios de autoevaluación

Ejercicios de Programación en Python

Instrucciones: De conformidad con el material presentado, realice y ejecute en

Python cada uno de los ejercicios que se detallan a continuación:

Parte I. Ejercicios de estructura básica

Ejercicio 1.
# Realiza un programa que reciba una cantidad de minutos y muestre por pantalla a
# cuantas horas y minutos corresponde.

minutos = int(input("Introduce la cantidad de minutos:"))

res_horas = minutos // 60
res_min = minutos % 60
print(res_horas,"horas y",res_min,"minutos.")

Ejercicio 2.
# Un vendedor recibe un sueldo base mas un 10% extr a por comisión de sus ventas,
# el vendedor desea saber cuanto dinero obtendrá por concepto de comisiones por
# las tres ventas que realiza en el mes y el total que recibirá en el mes tomando
# en cuenta su sueldo base y comisiones.

sueldo_base = float(input("Dime el sueldo base:"))

venta1 = float(input("Dime precio de la venta 1:"))
venta2 = float(input("Dime precio de la venta 2:"))
venta3 = float(input("Dime precio de la venta 3:"))
comision = venta1 * 0.1 + venta2 * 0.1 + venta3 * 0.1
print("Comisión por ventas:",comision)
print("Sueldo total:", sueldo_base + comision)

46
Ejercicio 3.
# Una tienda ofrece un descuento del 15% sobre el total de la compra y un
cliente
# desea saber cuanto deberá pagar finalmente por su compra.

precio = float(input("Dime el precio:"))

print("Precio final:",precio - precio * 0.15)

Ejercicio 4.
# Un alumno desea saber cual será su calificación final en la materia de
Algoritmos
# Dicha calificación se compone de los siguientes porcentajes:
# * 55% del promedio de sus tres calificaciones parciales.
# * 30% de la calificación del examen final.
# * 15% de la calificación de un trabajo final.

parcial1 = float(input("Dime la nota del parcial 1:"))

parcial2 = float(input("Dime la nota del parcial 2:"))
parcial3 = float(input("Dime la nota del parcial 3:"))
examen = float(input("Dime la nota del examen:"))
trabajo = float(input("Dime la nota del trabajo:"))
nota = ((parcial1 + parcial2 + parcial3) / 3) * 0.55 + 0.3 * examen +
0.15 * trabajo
print("nota final:", nota)

Ejercicio 5.
# Pide al usuario dos números y muestra la "distancia" entre ellos
# (el valor absoluto de su diferencia, de modo que el resultado sea
siempre positivo).

num1 = int(input("Dime el número 1:"))

num2 = int(input("Dime el número 2:"))
print("Distancia:", abs(num1 - num2))

Ejercicio 6.
# Realizar un algoritmo que lea un número y que muestre su raíz cuadrada
y su raíz cúbica.
# Python3 no tiene ninguna función predefinida que permita calcular la
raíz cúbica, ¿Cómo se puede calcular?

import math
num = int(input("Dime el número:"))
print("Raíz cuadrada:",math.sqrt(num))
print("Raíz cúbica:",num ** (1 / 3))

47
Ejercicio 7.
# Dado un número de dos cifras, diseñe un algoritmo que permita obtener
el
# número invertido.

num = int(input("Dime un número de dos cifras:"))

decenas = num // 10
unidades = num % 10
print("Primera cifra (decenas):",decenas)
print("Segunda cifra (unidades):",unidades)

Ejercicio 8.
# Dos vehículos viajan a diferentes velocidades (v1 y v2) y están
distanciados
# por una distancia d.
# El que está detrás viaja a una velocidad mayor. Se pide hacer un
algoritmo
# para ingresar la distancia entre los dos vehículos (km) y sus
respectivas
# velocidades (km/h) y con esto determinar y mostrar en que tiempo
(minutos)
# alcanzará el vehículo más rápido al otro.

velocidad1 = float(input("Dime la velocidad del coche 1 (km/h):"))

velocidad2 = float(input("Dime la velocidad del coche 2 (km/h):"))
distancia = float(input("Dime la distancia entre los coches (km):"))
tiempo = distancia / abs(velocidad1 - velocidad2)
tiempo = tiempo * 60
print("Lo alcanza en",tiempo,"minutos.")

Ejercicio 9.
# Un ciclista parte de una ciudad A a las HH horas, MM minutos y SS
segundos.
# El tiempo de viaje hasta llegar a otra ciudad B es de T segundos.
# Escribir un algoritmo que determine la hora de llegada a la ciudad B.

horapartida = int(input("Hora de salida:"))

minpartida = int(input("Minutos de salida:"))
segpartida = int(input("Segundos de salida:"))
segviaje = int(input("Tiempo que has tardado en segundos:"))
# Convierto la hora de salida a segundos
seginicial = horapartida * 3600 + minpartida*60 + segpartida;
# Le sumo los segundos que he tardado
segfinal = seginicial + segviaje;
# Convierto los segundos totales a hora, minúto y segundos
horallegada = segfinal // 3600;
minllegada = (segfinal % 3600) // 60;
segllegada = (segfinal % 3600) % 60;
# Muestro la hora de llegada
print("Hora de llegada")
print(horallegada,":",minllegada,":",segllegada)

48
Ejercicio 10.
# Pedir el nombre y los dos apellidos de una persona y mostrar las
iniciales.

nombre = input("Dime tu nombre:")

apellido1 = input("Dime tu primer apellido:")
apellido2 = input("Dime tu segundo apellido:")

inicial = nombre[0]
inicial = inicial + apellido1[0]
inicial = inicial + apellido2[0]
# Aunque no lo hemos estudiado vamos a usar el método upper para
convertir a mayúsculas
inicial = inicial.upper()
print("Las iniciales son:",inicial)

Parte II. Ejercicios de iteración o bucles

Ejercicio 1.
# Crea una aplicación que pida un número y calcule su factorial (El
factorial de
# un número es el producto de todos los enteros entre 1 y el propio
número y se
# representa por el número seguido de un signo de exclamación.
# Por ejemplo 5! = 1x2x3x4x5=120)

resultado = 1;
num=int(input("Dime un número:"))
contador = 2;
while contador <= num:
resultado = resultado * contador;
contador = contador + 1;
print("El resultado es", resultado)

Ejercicio 2.
# Algoritmo que pida números hasta que se introduzca un cero. Debe
imprimir la suma
# y la media de todos los números introducidos.

suma = 0
cont =0

# Con el mientras si el primer número es 0 no va a entrar en el bucle

num=int(input("Número (0 para salir):"))
while num != 0:
suma = suma + num
cont = cont + 1
num=int(input("Número (0 para salir):"))

49
# Si cont=0 no puedo realizar la división
if cont > 0:
media = suma / cont
else:
media = 0

print("Suma:",suma)
print("Media:",media)

# Otra manera de realizar el ejercicio 2, que pida números hasta que se

introduzca un cero. Debe imprimir la suma
# y la media de todos los números introducidos.

suma = 0
cont =0
while True:
num=int(input("Número (0 para salir):"))
suma = suma + num
# Si num=0 no debemos tenerlo en cuenta para calcular la media
if num !=0:
cont = cont + 1
if num == 0:
break
# Si cont=0 no puedo realizar la división
if cont != 0:
media = suma / cont
else:
media = 0

print("Suma:",suma)
print("Media:",media)

Ejercicio 3.
# Escribe un programa que dados dos números, uno real (base) y un entero
positivo
# (exponente), saque por pantalla el resultado de la potencia. No se
puede
# utilizar el operador de potencia.

base = int(input("Dame la base de la potencia:"))

while True:
exponente = int(input("Dame el exponente de la potencia:"))
if exponente<0:
print("ERROR: El exponente debe ser positivo")
if exponente >= 0:
break;
potencia = 1
for i in range(1, exponente + 1):
potencia = potencia * base
print("Potencia:",potencia)

50
Ejercicio 4.

# Escribe un programa que diga si un número introducido por teclado es o

no primo.
# Un número primo es aquel que sólo es divisible entre él mismo y la
unidad.
# Nota: Es suficiente probar hasta la raíz cuadrada del número para ver
si es
# divisible por algún otro número.

es_primo = True
numero_es_primo = int(input("Introduce un número para comprobar si es
primo:"))
for num in range(2, numero_es_primo):
if numero_es_primo % num == 0:
es_primo = False
if es_primo:
print("Es Primo")
else:
print("No es Primo")

Ejercicio 5.
# Una empresa tiene el registro de las horas que trabaja diariamente un
empleado
# durante la semana (seis días) y requiere determinar el total de éstas,
así como
# el sueldo que recibirá por las horas trabajadas.

horas_acum = 0
sueldo_por_hora = float(input("Introduce el sueldo por hora:"))
for dia in range(1, 7):
horas = int(input("¿Cuántas horas has trabajado el día %d ?:" %
dia))
horas_acum = horas_acum + horas
print("Horas acumuladas en la semana:",horas_acum)
print("Sueldo:",sueldo_por_hora*horas_acum)

Ejercicio 6.
# Una persona se encuentra en el kilómetro 70 de una carretera, otra se
encuentra
# en el km 150, los coches tienen sentido opuesto y tienen la misma
velocidad.
# Realizar un programa para determinar en qué kilómetro de esa carretera
se
# encontrarán.

km1 = 70
km2 = 150
while km1 != km2:
km1 = km1+1

51
 km2 = km2-1

print("Se encuentran en el km:",km1)

Ejercicio 7.
# Una persona adquirió un producto para pagar en 20 meses. El primer mes
pagó 10
# colones, el segundo 20 colones, el tercero 40 colones y así
sucesivamente.
# Realizar un algoritmo para determinar cuánto debe pagar mensualmente y
el total
# de lo que pagó después de los 20 meses.

pago_acum = 0
pago = 10
for mes in range(1, 21):
pago_acum = pago_acum + pago
pago = pago * 2
print("Al final de los 20 meses tuvo que pagar: ",pago_acum)

Ejercicio 8.
# Una empresa les paga a sus empleados con base en las horas trabajadas
en la semana.
# Realice un algoritmo para determinar el sueldo semanal de N
trabajadores
# y, además, calcule cuánto pagó la empresa por los N empleados.

horas_acum = 0
trabajadores = int(input("¿Cuántos trabajadores tiene la empresa?:"))
sueldo_por_hora = float(input("Sueldo por hora:"))
for trabajador in range(1, trabajadores + 1):
horas_por_semana = int(input("¿Cuántas horas ha trabajado el
trabajador %d ?:" % trabajador))
horas_acum = horas_acum + horas_por_semana
print("El trabajador %d tiene de sueldo %f" %
(trabajador,horas_por_semana*sueldo_por_hora))
print("El pago a los %d trabajadores es: %f" %
(trabajadores,horas_acum*sueldo_por_hora))

Ejercicio 9.
# Hacer un programa que muestre un cronometro, indicando las horas,
minutos y segundos.

import os
import time
for hora in range(0,24):
for minuto in range(0,60):
for segundo in range(0,60):
os.system("clear")

52
 print(hora,":",minuto,":",segundo)
time.sleep(1)

Ejercicio 10.
# Realizar un ejemplo de menú, donde podemos escoger las distintas
opciones hasta
# que seleccionamos la opción de "Salir".

while True:
# mostrar menu
print("Menú de recomendaciones")
print(" 1. Literatura")
print(" 2. Cine")
print(" 3. Música")
print(" 4. Videojuegos")
print(" 5. Salir")
# ingresar una opcion
opcion = int(input("Elija una opción (1-5): "))
# procesar esa opción
if opcion == 1:
print("Lecturas recomendables:")
print(" + Esperándolo a Tito y otros cuentos de fútbol (Eduardo
Sacheri)")
print(" + El juego de Ender (Orson Scott Card)")
print(" + El sueño de los héroes (Adolfo Bioy Casares)")
elif opcion == 2:
print("Películas recomendables:")
print(" + Matrix (1999)")
print(" + El último samuray (2003)")
print(" + Cars (2006)")
elif opcion == 3:
print("Discos recomendables:")
print(" + Despedazado por mil partes (La Renga, 1996)")
print(" + Búfalo (La Mississippi, 2008)")
print(" + Gaia (Mago de Oz, 2003)")
elif opcion == 4:
print("Videojuegos clásicos recomendables")
print(" + Día del tentáculo (LucasArts, 1993)")
print(" + Terminal Velocity (Terminal Reality/3D Realms, 1995) ")
print(" + Death Rally (Remedy/Apogee, 1996)")
elif opcion == 5:
print("Gracias, vuelva prontos")
break;
else:
print("Opción no válida")

53
Referencias:

Campbell, S. (2023, junio 10). Python tutorial for beginners: Learn

programming basics [PDF]. Guru99. https://www.guru99.com/python-
tutorials.html

Gaddis, T. (2019). Starting Out with Python. Editorial Pearson. Cuarta

Edición.

Mancebo, M. C. (2021). Introducción a la programación en Python. Canal

UNED España.
https://canal.uned.es/video/60b4ba5bb609235dc15173d2

Massachusetts Institute of Technology MIT (2010).

Propositions. https://ocw.mit.edu/courses/electrical-engineering-and-
computer-science/6- 042j-mathematics-for-computer-science-
fall2010/readings/MIT6_042JF10_chap01.pdf

Setvens, A. (2011). CS101 Lecture 11: Number Systems and Binary

Numbers.
http://www.cs.bu.edu/courses/cs101b1/slides/CS101.Lect11.BinaryN
umbers.ppt.pdf

54