Código: UNITEC-INGMP01

Versión: 01
Manual de prácticas de Página 1/25
Estructura de datos Sección ISO 8.3
Fecha de
23 de mayo de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputode Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Este manual de prácticas se refiere a la materia de Estructura de Datos que

es cursada por alumnos de las carreras de Ingeniería en sistemas y de la Licenciatura
en diseño, animación y arte digital, el objetivo es entregarle al estudiante un
documento que le permita aplicar, actuar, identificar, usar, simular, emplear,
demostrar, manipular, practicar , desarrollar, construir y resolver ejercicios que
impliquen los temas integrados en el temario y que construyan en el esquema mental
del estudiante su aplicación dentro de la carrera que están cursando. Esperando sea
significativo para su formación y proyección de su futuro profesional.

Manual de prácticas de

Estructura de Datos

Elaborado por: Revisado por: Autorizado por: Vigente desde:

Mtra. Patricia Barba Mtra. Patricia Barba

Dorado Dorado

M. en C. Omar Pérez Directora Académica Directora Académica

Romero Ingeniería-CyAD Ingeniería-CyAD 23 de mayo de 2024
Tel. (55) 21263400 Tel. (55) 21263400
Ext. 69403 Ext. 69403

pbarbado@mail.unite pbarbado@mail.uni
c.mx tec.mx

1
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 2/25
Estructura de datos Sección ISO 8.3
Fecha de
23 de mayo de 2024
emisión

Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputode Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Índice de prácticas

Práctica 1: Funciones ......................................................................................................................... 3

Práctica 2: Apuntadores .................................................................................................................. 41

Práctica 3: Recursividad................................................................................................................... 82

Práctica 4: Estructuras ................................................................................................................... 114

Practica 5: Algoritmos de búsqueda………………………………………………………………………………………….138

Practica 6: Listas____________________________………………………………………………………………….159

Practica 7: Pilas________________________________________________________________XXX

Practica 8: Colas________________________________________________________________XXX

Practica 9: Árboles______________________________________________________________XXX

2
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 3/25
Estructura de datos Sección ISO 8.3
Fecha de
23 de mayo de 2024
emisión

Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputode Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Práctica #1
Funciones
1. Seguridad en la ejecución

Peligro o Fuente de energía Riesgo asociado

1 Tensión alterna Electrocución

2. Objetivos de aprendizaje

OBJETIVO GENERAL: Analizar estructuras de datos lineales y recursivas,

algoritmos de búsqueda y clasificación de datos, para codificar aplicaciones de
procesamiento y estructuración de datos.

1.- Funciones
1.1.- Definición de función
1.2.- Declaración de función
1.3.- Prototipo de funciones
1.4.- Aplicación de funciones

OBJETIVOS ESPECÍFICOS:
 Crear un programa que implemente funciones.
 Implementar una declaración de funciones.
3
  Realizar prototipo de funciones
 Desarrollar una aplicación de funciones.

3. Introducción

1.1.- Definición de función en PYTHON

1.2.- Declaración de función
1.3.- Prototipo de funciones
1.4.- Aplicación de funciones

Al igual que en todos los lenguajes de programación, en Python tenemos disponible

el uso de funciones. Aquí te mostraremos su concepto, las maneras en que puedes
definirlas y algunos ejemplos para comenzar.
Una función en Python (y en cualquier otro lenguaje de programación) es un bloque
de líneas de código o un conjunto de instrucciones cuya finalidad es realizar una
tarea específica. Puede reutilizarse a voluntad para repetir dicha tarea.
¿Cómo definir una función en Python?
Para definir una función nueva en Python utiliza la palabra reservada def, seguida
del nombre que le quieres dar a la función. A continuación, añade los paréntesis con
los parámetros de entrada de la función seguidos de dos puntos (:). Después,
normalmente en otra línea de código, agrega el bloque de instrucciones que
quieres que se ejecuten cada vez que se invoca a la función.
Dentro de este bloque de instrucciones (casi siempre al final y de forma opcional)
se coloca una sentencia de retorno que no es más que el valor que deseas que
devuelva la función: para esto usa la palabra reservada return.
Una función en Python siempre devolverá un valor; es decir, si no se añade una
sentencia de retorno (return), se devolverá el valor predeterminado None.

# ejemplo de definición de una función

def suma(a, b):
return a + b
result = suma(8,5)
# result = 13

También puedes definir valores predeterminados para los parámetros de entrada

de tus funciones. Esto te permite indicar que dichos parámetros son opcionales, es
decir, que pueden no ser informados al momento de invocar la función; sin embargo,
como cuentan con parámetros por default previamente definidos, la función seguirá
ejecutándose con normalidad.

def suma(a, b=8):

return a + b
result = suma(5)
# result = 13

4
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Estructura Página 4/25
de datos Sección ISO 8.3
Fecha de
23 de mayo de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputode Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Consideraciones adicionales acerca de las funciones en Python

Algunas consideraciones que debemos tener en cuenta al momento de crear
y utilizar nuestras propias funciones en Python son:
 Siempre retornar un valor de respuesta.
 Definir valores por default para todos los parámetros de entrada que sea posible.
 Verificar que la cantidad de parámetros con que invocamos la función son los mismos
que se definieron al momento de crear la función.
 Python es un lenguaje que utiliza la indentación para delimitar los bloques de código,
por lo que tenemos que verificar que las líneas que queremos que pertenezcan a la
función estén correctamente indentadas.
 Otra recomendación es utilizar solo variables locales y evitar el uso de variables
globales para evitar comportamientos inesperados.
 Python es un lenguaje interpretado: aunque las líneas de código de la definición de la
función contengan algún tipo de error, el intérprete de Python lo señalará hasta el
momento en que se invoque la función.
 8 ejemplos de funciones en Python
 Aquí listamos algunos ejemplos de funciones incorporadas que nos proporciona Python:
 1. Función print()
 Imprime en la consola de comandos.
 >>> print('¡Hola, mundo!')
 ¡Hola, mundo!
 2. Función len()
 Devuelve la longitud (el número de elementos) de un objeto.
 >>> len(['a','b','c','d','e'])
 5
 >>> len('¡Hola, mundo!')
 11
 3. Función max()
 Devuelve el elemento más grande en un iterable (todos los elementos deben ser del mismo tipo) o el más
grande de dos o más argumentos.
 >>> max(2, 3)
 3
 >>> max([1, 2, 3])
 3
 >>> max('a', 'b', 'c')
 'c'
 4. Función min()
 Devuelve el elemento más pequeño en un iterable o el más pequeño de dos o más argumentos.
5
 >>> min(2, 3)
 2
 >>> min([1, 2, 3])
 1
 >>> min('a', 'b', 'c')
 'a'
 5. Función divmod(a, b)
 Devuelve el cociente y el sobrante de dividir dos números.
 >>> divmod(5,2)
 (2, 1)
 >>> divmod(13.5,2.5)
 (5.0, 1.0)
 6. Función abs()
 Retorna el valor absoluto de un número.
 >>> abs(5)
 5
 >>> abs(-5)
 5
 7. Función complex(real, imag)
 Retorna el número complejo con el valor real + imag*1j. También convierte una cadena o un número a un
número complejo.
 >>> complex(5,1)
 (5+1j)
 >>> complex('1+5j')
 (1+5j)
 >>> complex(5j)
 5j
 >>> complex(1+5j)
 (1+5j)
 >>> complex(1)(1+0j)
 8. Función pow(base, exp)
 Retorna base elevado a exp.
 >>> pow(5,2)
 25
 >>> pow(5,-2)
 # Result = 1/25
 0.04

6
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 5/25
Estructura de datos Sección ISO 8.3
Fecha de
23 de mayo de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputode Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Los conceptos anteriores forman los conceptos básicos para poder abordar la
programación de funciones en PYTHON. En la práctica profesional, también se
acostumbra utilizar FUNCIONES de terceros o que no necesariamente fueron
creadosdesde un inicio en el proyecto original, para ello la incorporación de clases
externaso de archivos se hace través de bibliotecas que tienen un código que no
necesariamente es accesible para su modificación, pero sí para su uso.
4. Material y equipo

Computadora

5. Desarrollo

Actividad 1. introducción e instalación de Python:

5.1.- Abrir el navegador web y dirigirte a la página oficial de PYTHON:

7
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 6/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputode Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

5.2.- Dirigirte al menú Downloads de la página oficial de PYTHON:

5.3.- Descargar LA VERSIÓN ACTUAL de la página oficial de PYTHON y proceder a la

instalación:

8
5.4.- Una vez instalado ingresa al menú principal de Windows y encuentra la versión
instalada como sigue:

5.5.- Dar click al IDLE instalado y abrirá una pantalla como sigue:

5.6.- Dar click en el IDLE instalado en la opción “Options” y después en “Configure

IDLE” y abrirá una pantalla como sigue:

9
10
5.7.- A continuación escribir la siguiente línea de código en el IDLE:

Python 3.12.3 (tags/v3.12.3:f6650f9, Apr 9 2024, 14:05:25) [MSC v.1938 64 bit (AMD64)] on
win32
Type "help", "copyright", "credits" or "license()" for more information.
print("Hola mundo")
Hola mundo

11
5.8.- A continuación abrir un nuevo archivo en el IDLE y escribir las siguientes
instrucciones:

12
13
14
Actividad 2. Variables en Python
5.9.- A continuación abrir un nuevo archivo en el IDLE y escribir las siguientes
instrucciones:

print("Esto es una suma")

numero_uno=2
numero_dos=4
resultado=numero_uno+numero_dos
print(resultado)
15
 Manipulación de cadenas de caracteres (Strings)

mensaje="Hola"
mensaje+=" "
mensaje+="Ernesto"
print(mensaje)

mensaje="Hola"
espacio=" "
nombre="Ernesto"
print(mensaje+espacio+nombre)

16
mensaje="Hola"
espacio=" "
nombre="Ernesto"
print(mensaje+espacio+nombre)

print("Concatenación:")

mensaje= "Hola"
espacio= " "
nombre="Ernesto"
print(mensaje + espacio + nombre)

numero_uno=4
numero_dos=6
resultado=numero_uno + numero_dos
print(El resultado de la suma es: " + resultado)

Hola Ernesto
Concatenación:
Hola Ernesto
Traceback (most recent call last):
File "C:/Users/omar_perezr/Desktop/Programa5.py", line 17, in <module>
print("El resultado de la suma es: " + resultado)
TypeError: can only concatenate str (not "int") to str
numero_uno=4
numero_dos=6
resultado=numero_uno + numero_dos
resultado = str(resultado)
print(El resultado de la suma es: " + resultado)

17
mensaje="Hola Ernesto"
buscar_subcadena=mensaje.find("Ernesto")
print(buscar_subcadena)

mensaje="Hola Ernesto"
buscar_subcadena=mensaje.find(nombre)
print(buscar_subcadena)

mensaje= "Hola Ernesto"

extraer_subcadena=mensaje[1:8]
print(extraer_subcadena)

print("Comparación:")
mensaje_uno= "Hola"
mensaje_dos= "Hola"
print(mensaje_uno == mensaje_dos)

18
 Salida:
Comparación:
True

mensaje_uno= "Hola"
mensaje_dos= "Hola1"
print(mensaje_uno == mensaje_dos)

Comparación:
False

Palabras reservadas en Python

print = 5
Print = 6
resultado = print + Print

print(resultado)

Traceback (most recent call last):

File "C:/Users/omar_perezr/Desktop/Programa8.py", line 5, in <module>
print(resultado)
TypeError: 'int' object is not callable

prinT = 5
Print = 6
resultado = prinT + Print

print(resultado)
=============================================== RESTART:
C:/Users/omar_perezr/Desktop/Programa8.py
===============================================
11

19
 Operadores aritméticos en Python
print("suma:")

numero_uno = 5
numero_dos = 4

resultado = numero_uno + numero_dos

print("El resultado de la suma es:" + str(resultado))

suma:
El resultado de la suma es:9

print("resta:")

numero_uno = 5
numero_dos = 4

resultado = numero_uno - numero_dos

print("El resultado de la resta es:" + str(resultado))

resta:
El resultado de la resta es:1

print("multiplicación:")

numero_uno = 5
numero_dos = 4

resultado = numero_uno * numero_dos

print("El resultado de la multiplicación es:" + str(resultado))

multiplicación:
El resultado de la multiplicación es:20

print("exponente:")

numero_uno = 2
exponente = 5

resultado = numero_uno ** exponente

print("El resultado del exponente es:" + str(resultado))

exponente:
El resultado del exponente es:32

print("división:")

numero_uno = 4
20
numero_dos = 2

resultado = numero_uno / numero_dos

print("El resultado de la división es:" + str(resultado))

división:
El resultado de la división es:2.0

print("módulo o resto:")

numero_uno = 30
numero_dos = 8

resultado = numero_uno % numero_dos

print("El resultado del módulo es:" + str(resultado))

módulo o resto:
El resultado del módulo es:6

print("división entera:")

numero_uno = 4
numero_dos = 2

resultado = numero_uno // numero_dos

print("El resultado de la división entera es:" + str(resultado))

división entera:
El resultado de la división entera es:2

Comentarios en Python

#Esto es un comentario
print("Hola")

=============================================== RESTART:
C:/Users/omar_perezr/Desktop/Programa10.py
21
==============================================
Hola

#Esto es un comentario
print("Hola")

"Esto es otro comentario"

=============================================== RESTART:
C:/Users/omar_perezr/Desktop/Programa10.py
==============================================
Hola

""" Hola esto

es un
comentario
s
s
s
s
"""

=============================================== RESTART:
C:/Users/omar_perezr/Desktop/Programa10.py
==============================================
Hola

Tipos de datos en Python

22
#Tipo de dato entero o largo
numero = 15 #Tipado dinámico
print(numero, type(numero))

============ RESTART: C:/Users/omar_perezr/Desktop/Tipos_De_Datos.py

===========
15 <class 'int'>

#Tipo de dato entero o largo

numero = 15 #Tipado dinámico
print(numero, type(numero))

#Tipo de dato flotante

numero_flotante=15.5
print(numero_flotante,type(numero_flotante))

#Tipo de dato Número complejo

#complex
numero_complejo = 5 + 6j
print(numero_complejo, type(numero_complejo))

#Tipo de dato String

nombre = "Ernesto"
print(nombre, type(nombre))

#Tipo de dato Booleano

verdadero_falso = 3 == 3
print(verdadero_falso, type(verdadero_falso))

============ RESTART: C:/Users/omar_perezr/Desktop/Tipos_De_Datos.py

===========
15 <class 'int'>
15.5 <class 'float'>
(5+6j) <class 'complex'>
23
Ernesto <class 'str'>
True <class 'bool'>

Actividad 3. Entrada de datos desde el teclado

palabra = input("Introduce una palabra: ")

num_int = int(input("Introduce un número entero: "))
num_float = float(input("Introduce un número flotante: "))
num_complex = complex(input("Introduce un número complejo:"))

print("String: ", palabra)

print("Entero: ", num_int)
print("Flotante: ", num_float)
print("Número complejo: ", num_complex).

Python 3.12.3 (tags/v3.12.3:f6650f9, Apr 9 2024, 14:05:25) [MSC v.1938 64 bit (AMD64)] on
win32
Type "help", "copyright", "credits" or "license()" for more information.

=========== RESTART: C:/Users/omar_perezr/Desktop/Entrada_De_Datos.py ==========

Introduce una palabra: Hola omar
Introduce un número entero: 10
Introduce un número flotante: 10.5
Introduce un número complejo:5+1j
String: Hola omar
Entero: 10
Flotante: 10.5
Número complejo: (5+1j)

nombre = input("¿Cual es tu nombre?: ")

print("Hola " + nombre + ", vamos a realizar una suma.")

num_uno= int(input("Por favor introduce el primer valor: "))

num_dos = int(input("Por favor introduce el segundo valor: "))

resultado = num_uno + num_dos

print(nombre + " El resultado de la suma es: ", resultado)

========== RESTART: C:/Users/omar_perezr/Desktop/Entrada_De_Datos2.py ==========

¿Cual es tu nombre?: Omar
Hola Omar, vamos a realizar una suma.
Por favor introduce el primer valor: 10
Por favor introduce el segundo valor: 5
Omar El resultado de la suma es: 15

24
 Sentencias condicionales simples en Python (if)

==== RESTART: C:/Users/omar_perezr/Desktop/Condiciones_Simples.py ===

Sistema para calcular el promedio de un alumno.
para comenzar, ¿Cual es tu nombre?: omar
omar¿Cual es tu calificación en matemáticas?: 9
omar¿Cual es tu calificación en quimica?: 8
omar¿Cual es tu calificación en biología?: 7
Felicidadesomar "Aprobaste" con un promedio de: 8
Fin.

print("Sistema para calcular el promedio de un alumno.")

nombre = input("para comenzar, ¿Cual es tu nombre?: ")

matematicas = int(input(nombre + "¿Cual es tu calificación en matemáticas?: "))

quimica = int(input(nombre + "¿Cual es tu calificación en quimica?: "))
biología = int(input(nombre + "¿Cual es tu calificación en biología?: "))

promedio = (matematicas + quimica + biología) / 3

promedio = int(promedio)

if promedio >= 6:
print('Felicidades' + nombre + ' "Aprobaste" con un promedio de: ', promedio)

print("Fin.")

25
 Sentencias condicionales compuestas en Python (if - else)

num_uno = 5
if num_uno==5:
print("El npumero es cinco.")

else:
print("El número No es cinco.")

print("Fin.")

==== RESTART: C:/Users/omar_perezr/Desktop/Condición_Compuesta.py ===

El npumero es cinco.
Fin.

num_uno = 5
if num_uno==5:
print("El npumero es cinco.")

else:
print("El número No es cinco.")

print("Fin.")

num_uno = 10
if num_uno==5:
print("El npumero es cinco.")

else:
print("El número No es cinco.")

print("Fin.")

==== RESTART: C:/Users/omar_perezr/Desktop/Condición_Compuesta.py ===

El npumero es cinco.
Fin.
El número No es cinco.
Fin.

26
Ejercicios:

1.- Desarrollar un sistema que pregunte 2 números enteros con decimal y que entregue los
siguientes resultados:
a).- La suma de los dos números
b).-La resta de los dos números
c).-La multiplicación de los dos números
d).-La división donde muestre el resultado de la división y el resto de la división
e).-El primer número elevado al segundo número y muestre su resultado.

2.- Desarrollar un sistema que calcule el promedio de 5 materias de un alumno y que nos
indique su promedio y si está aprobado o reprobado, considere que si promedio es menor o
igual a 5 se considera alumno reprobado.

Otro ejemplo de Condicionales:

print("Sistema para calcular el promedio de un alumno")

nombre=input("Para comenzar, ¿Cual es tu nombre?:")

matematicas=float(input(nombre+"¿Cual es tu calificación en matemáticas?:"))

quimica=float(input(nombre+"¿Cual es tu calificación en quimica?:"))
biologia=float(input(nombre+"¿Cual es tu calificación en biologia?:"))

promedio=(matematicas+quimica+biologia)/3

if promedio>= 6:
print('Felicidades' + nombre + ' "aprobaste" con un promedio de: ' , promedio)
print('Felicidades' + nombre + ' "aprobaste" con un promedio de: ' , round(promedio,2))
else:
print("Lo sentimos " + nombre + " has 'reprobado' con un promedio de: ", promedio)
print("Lo sentimos " + nombre + " has 'reprobado' con un promedio de: ", round(promedio,2))

print("Fin.")

==== RESTART: C:/Users/omar_perezr/Desktop/Condicion_Compuesta.py ===

Sistema para calcular el promedio de un alumno
Para comenzar, ¿Cual es tu nombre?:OMAR
OMAR¿Cual es tu calificación en matemáticas?:5
OMAR¿Cual es tu calificación en quimica?:6
OMAR¿Cual es tu calificación en biologia?:5
Lo sentimos OMAR has 'reprobado' con un promedio de: 5.333333333333333
Lo sentimos OMAR has 'reprobado' con un promedio de: 5.33
Fin.

27
 Sentencias condicionales múltiples en Python (elif)

print("===================================")
print("¡¡Convertidor de números a letras!!")
print("===================================")

num_uno=int(input("¿Cúal es el número que deseas convertir?:"))

if num_uno==1:
print("El número es 'Uno'")
elif num_uno==2:
print("El número es 'Dos'")
elif num_uno==3:
print("El número es 'Tres'")
elif num_uno==4:
print("El número es 'Cuatro'")
elif num_uno==5:
print("El número es 'Cinco'")
else:
print("Este programa solo puede convertir hasta el número 5")

print("Fin.")

==== RESTART: C:/Users/omar_perezr/Desktop/Condicion_Multiple.py ====

===================================
¡¡Convertidor de números a letras!!
===================================
¿Cúal es el número que deseas convertir?:3
El número es 'Tres'
Fin.

28
 Sentencias condicionales anidadas en Python
print("===================================")
print("¡¡Conversor!!")
print("=================================== \n")

print("mENÚ DE OPCIONES: \n")

print("Menú de opciones: \n")

print("Presiona 1 para convertir de número a palabra.")
print("Presiona 2 para convertit de palabra a número. \n")

opcion = int(input("¿Cual es tu opción deseada?:"))

if opcion==1:

print("\n Conversor de número a palabra. \n")

opcion_uno= int(input("¿Cual es el número que deseas convertir a palabra?: "))

if num_uno==1:
print("El número es 'Uno'")
elif num_uno==2:
print("El número es 'Dos'")
elif num_uno==3:
print("El número es 'Tres'")
elif num_uno==4:
print("El número es 'Cuatro'")
elif num_uno==5:
print("El número es 'Cinco'")
else:
print("El número seleccionado no está registrado.")

elif opcion==2:
print("\n Conversor de palabra a número. \n")

opcion_dos=input("Cual es la palabra que deseas convertir a número?:")

opcion_dos= opcion_dos.lower()

if opcion_dos == "uno":
print("El número es '1'")
elif opcion_dos=="dos":
print("El número es '2'")
elif opcion_dos=="tres":
print("El número es '3'")
elif opcion_dos=="cuatro":
print("El número es '4'")
elif opcion_dos=="cinco":
print("El número es '5'")
29
 else:
print("El número seleccionado no esta registrado.")

else:
print("Opción no disponible.")

print("Fin.")

========== RESTART: C:\Users\omar_perezr\Desktop\Condicion_Multiple.py =========

===================================
¡¡Conversor!!
===================================

mENÚ DE OPCIONES:

Menú de opciones:

Presiona 1 para convertir de número a palabra.

Presiona 2 para convertit de palabra a número.

¿Cual es tu opción deseada?:2

Conversor de palabra a número.

Cual es la palabra que deseas convertir a número?:uno

El número es '1'
Fin.

Operadores relacionales en Python

print("Introduce dos números a comparar:\n")

num_uno = int(input("Introduce el primer número: "))

num_dos = int(input("Introduce el segundo número: "))

30
print("\n los número a comparar son: ", num_uno, " y ", num_dos, "\n")

if num_uno == num_dos:
print("Es igual...")

if num_uno != num_dos:
print("Es diferente...")

if num_uno < num_dos:

print("Es menor...")
if num_uno > num_dos:
print("Es mayor...")
if num_uno <= num_dos:
print("Es menor o igual...")
if num_uno >= num_dos:
print("Es mayor o igual...")

======= RESTART: C:/Users/omar_perezr/Desktop/Operadores_relacionales.py

=======
Introduce dos números a comparar:

Introduce el primer número: 9

Introduce el segundo número: 5

los número a comparar son: 9 y 5

Es diferente...
Es mayor...
Es mayor o igual...

31
Ejercicios:

32
Ejercicio Práctico:

33
print("***************************************")
print("* Sistema de control vacacional Rappi *")
print("*************************************** \n")

nombre_empleado = input("Por favor introduce el nombre del empleado: ")

clave_departamento = int(input("Por favor introduce la clave del departamento: "))
antiguedad_empleado = float(input("Por favor introduce los años laborados del empleado: "))

if clave_departamento == 1:

if antiguedad_empleado == 1 and antiguedad_empleado < 2:

print("El empleado ", nombre_empleado, " tiene derecho a 6 días de vacaciones.")
elif antiguedad_empleado >= 2 and antiguedad_empleado <= 6:
34
 print("El empleado ", nombre_empleado, " tiene derecho a 14 días de vacaciones.")
elif antiguedad_empleado >= 7:
print("El empleado ", nombre_empleado, " tiene derecho a 20 días de vacaciones.")
else:
print("El empleado ", nombre_empleado, " aún no tiene derecho a vacaciones.")

elif clave_departamento == 2:

if antiguedad_empleado == 1 and antiguedad_empleado < 2:

print("El empleado ", nombre_empleado, " tiene derecho a 7 días de vacaciones.")
elif antiguedad_empleado >= 2 and antiguedad_empleado <= 6:
print("El empleado ", nombre_empleado, " tiene derecho a 15 días de vacaciones.")
elif antiguedad_empleado >= 7:
print("El empleado ", nombre_empleado, " tiene derecho a 22 días de vacaciones.")
else:
print("El empleado ", nombre_empleado, " aún no tiene derecho a vacaciones.")

elif clave_departamento == 3:

if antiguedad_empleado == 1 and antiguedad_empleado < 2:

print("El empleado ", nombre_empleado, " tiene derecho a 10 días de vacaciones.")
elif antiguedad_empleado >= 2 and antiguedad_empleado <= 6:
print("El empleado ", nombre_empleado, " tiene derecho a 20 días de vacaciones.")
elif antiguedad_empleado >= 7:
print("El empleado ", nombre_empleado, " tiene derecho a 30 días de vacaciones.")
else:
print("El empleado ", nombre_empleado, " aún no tiene derecho a vacaciones.")

else:
print("La calve de departamento no existe, vuelve a intentarlo.")

print("******************************************************")
print("* Programa que determina si un número es par o impar *")
print("****************************************************** \n")

numero = int(input("Por favor introduce un número entero: "))

if numero % 2 == 0:
print("El número ", numero, " es par.")
elif numero % 2 == 1:
print("El número ", numero, " es impar.")

35
print("***************************************************************************")
print("* Programa para determinar ¿Cúal es el número más grande de tres números? *")
print("*************************************************************************** \n")

num_uno = int(input("Introduce el primer número:"))

num_dos = int(input("Introduce el segundo número:"))
num_tres = int(input("Introduce el tercer número:"))

if num_uno > num_dos and num_uno > num_tres:

print("El número ", num_uno, " es el número más grande de los tres.")
else:
if num_dos > num_tres:
print("El número ", num_dos, " es el número más grande de los tres.")
else:
print("El número ", num_tres, " es el número más grande de los tres.")

36
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 7/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Práctica #2
Apuntadores
1. Seguridad en la ejecución

Peligro o Fuente de energía Riesgo asociado

1 Tensión alterna Electrocución

2. Objetivos de aprendizaje

OBJETIVO GENERAL: El alumno aprenderá a utilizar los apuntadores en la

dirección de memoria RAM.

OBJETIVOS ESPECÍFICOS:
 Conocer el uso de apuntadores.
 Utilizar los operadores de dirección o indirección.
 Utilizar operador NULL y enviar o recibir apuntadores en una función.

2.- Apuntadores
2.1.- Definición de apuntador
2.2.- Operador de dirección de memoria
2.3.- Operador de indirección de memoria
2.4.- Operador NULL
2.5.- Apuntador de apuntadores
2.6.- Enviar y recibir apuntadores en una
función

37
3. Introducción

38
39
40
41
Operadores de asignación

42
43
44
45
46
47
nombre = "Hola "
nombre += input("Escribe tu nombre: ")

print(nombre, ", esto es el incremento y decremento de una variable \n")

print("incremento o aumento:")
x=1
print("El valor inicial de x es:", x)

x+=1
x+=1
x+=1
x+=1
print("El valor final de x es:", x, "\n")

print("decremento o disminución:")
print("El valor inicial de x es:", x)

x-=1
x-=1
x-=1
x-=1
print("El valor final de x es:", x)

48
4. Entregables a definir por el profesor.

5. Bibliografía
 MARTIN, Robert C. Código limpio: Manual de estilo para el desarrollo
ágil de software. España, Anaya Multimedia, 2012
 BELL, Douglas y PARR, Mike. C# para estudiantes. México, Pearson, 2010.
 GARCÍA PÉREZ-SCHOFIELD, Baltasar y ORTÍN SOLER, Francisco.
Programación avanzada orientada a objetos. España, Andavira Editora,
2013.
 SHALOM, Elad. SOLID Programming: in C#. Independently published,
2019.
 LANDA, Nicolás. GUÍA TOTAL DEL PROGRAMADOR C#. Buenos Aires,
Redusers,2010.

49
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 13/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Práctica #3
Recursividad, Estructuras,
Algoritmos de búsqueda, Listas,
Pilas y Colas
1. Seguridad en la ejecución

Peligro o Fuente de energía Riesgo asociado

1 Tensión alterna Electrocución

2. Objetivos de aprendizaje

OBJETIVO GENERAL: Entender el uso y funcionamiento de la recursividad,

estructuras, algoritmos de búsqueda, listas, pilas y colas en las estructuras de datos.

OBJETIVOS ESPECÍFICOS:
 Entender el funcionamiento de dos estructuras de datos y ser capaz de
utilizarlas junto con los métodos pertinentes para trabajar con ellas.
 Implementar un algoritmo de ordenación y uno de búsqueda en alguna de las
estructuras de datos creadas.

50
3.- Recursividad
3.1.- Definición de recursividad
3.2.- Encontrar caso base
3.3.- Graficamente cómo funciona la recursividad
3.4.- La función factorial como operación recursiva
3.5.- Representación recursiva de los números de Fibbonaci

4.-Estructuras
4.1.- Definición de estructura
4.2.- Ejemplos de estructuras
4.3.- Typedef
4.4.- Operador punto
4.5.- Operador flecha

5.-Algoritmos de búsqueda
5.1.- Método de la burbuja
5.2.- Método de selección
5.3.- Método de inserción
5.4.- Método de Shell
5.5.- Quicksort

6.-Listas
6.1.-Definición de lista
6.2.- Especificación y representación de listas
6.3.- Operaciones en las listas
6.4.- Implementación de listas
6.5.- Listas circulares
6.6.- Listas doblemente ligadas

7.- Pilas
7.1.- Definición de pila
7.2.-Especificación y representación de listas
7.3.- Operaciones en las pilas
7.4.- Implementación de pilas
7.5.- Aplicaciones de las pilas

8.- Colas
8.1.- Definición de cola
8.2.- Especificación y representación de colas
8.3.- Operaciones en las colas
8.4.- Implementación de colas
8.5.- Aplicaciones de las colas

51
3. Introducción

Recursividad
¿En qué trabajas? Estoy intentando arreglar los problemas que creé cuando
intentaba arreglar los problemas que creé cuando intentaba arreglar los problemas
que creé. Y así nació la recursividad.
La recursividad o recursión es un concepto que proviene de las matemáticas, y
que aplicado al mundo de la programación nos permite resolver problemas o tareas
donde las mismas pueden ser divididas en subtareas cuya funcionalidad es la
misma. Dado que los subproblemas a resolver son de la misma naturaleza, se
puede usar la misma función para resolverlos. Dicho de otra manera, una función
recursiva es aquella que está definida en función de sí misma, por lo que se llama
repetidamente a sí misma hasta llegar a un punto de salida.
Cualquier función recursiva tiene dos secciones de código claramente divididas:
 Por un lado tenemos la sección en la que la función se llama a sí misma.
 Por otro lado, tiene que existir siempre una condición en la que la función retorna
sin volver a llamarse. Es muy importante porque de lo contrario, la función se
llamaría de manera indefinida.
Veamos unos ejemplos con el factorial y la serie de fibonacci.

Calcular factorial
Uno de los ejemplos mas usados para entender la recursividad, es el cálculo del
factorial de un número n!. El factorial de un número n se define como la
multiplicación de todos sus números predecesores hasta llegar a uno. Por lo tanto
5, leído como cinco factorial, sería 5*4*3*2*1.
Utilizando un enfoque tradicional no recursivo, podríamos calcular el factorial de la
siguiente manera.

"""
Factorial de un número
"""

def factorial(numero):
if numero <= 0:
return 1
factorial = 1
while numero > 0:
factorial = factorial * numero
numero -= 1
return factorial

def factorial_recursivo(numero):
if numero <= 1:
return 1
return numero * factorial(numero-1)

valor = 5
f = factorial(valor)
print(f"El factorial de {valor} es {f}")
52
f = factorial(valor)
print(f"El factorial (calculado de manera recursiva) de {valor} es {f}")

Serie de Fibonacci
La sucesión de Fibonacci es la siguiente sucesión infinita de números naturales:

La sucesión comienza con los números 0 y 1, y a partir de estos cada termino es

la suma de los dos anteriores.
En la siguiente imagen, podemos observar un poco del proceso de la secuencia:

# Solicitamos la posición de la serie hasta la que debemos calcular

pos = int(input('Escriba que posición quiere de la serie de Fibonacci: '))
# Preguntamos si se desea desarrollar la serie
ans = input('Desea ver el resultado de toda la serie? ( S/N ) : ')
# Inicializamos las variables
iniFibo = 0
finFibo = 1
# Comenzamos el ciclo de calculo de Fibonacci hasta la posición indicada
for x in range(0,pos):
# Evaluamos las dos primeras posiciones de la serie
if x == 0:
finFibo = 0
elif x == 1:
finFibo = 1
# Si acepto desarrollar la serie se imprime la posición y el valor correspondiente
# La posicion se le suma 1 ya que el rango comienza en 0 y no en 1
if ans =='S' or ans == 's' :
print(f'Posicion: {x+1:>4} -- Valor en la serie de Fibonacci: {finFibo:>10} ')
# Guardamos el valor final de la seria antes de actualizarlo
sum = finFibo
# Actualizamos los valores de acuerdo al algoritmo
finFibo = finFibo + iniFibo
iniFibo = finFibo - iniFibo
# Imprime el valor final de la serie, independientemente si se desarrollo la serie o no
print(f'\nPosición Final: {x+1:>4} -- Valor en la serie de Fibonacci: {sum:>10} ')

Los parámetros end y sep

#Ejemplo para el parametro end

print("Esto es un", end="-*/")

53
print("ejemplo")

#Ejemplo para el parametro sep

print("1","2","3","4","5", sep="-")

Bucle o ciclo while

#Ejemplo 1
x=1

while x<3:
print(x)
x+=1

print("Fin.")

#Ejemplo 2

x=0
while x<1000:
print("Ernesto")
x+=1
Sucesión Fibonacci
num_uno, num_dos = 0, 1
while num_dos <= 1597:
print(num_uno, num_dos, end=" ")
num_uno = num_uno + num_dos
num_dos = num_uno + num_dos

Las sentencias break y continue con while

#Ejemplo para break

print("while con la sentencia break \n")

contador = 0
while contador < 10:
contador += 1

if contador == 5:
break

print("Valor actual de la variable: ", contador)

print("Fin del prgrama, la sentencia break se ha ejecutado.")

#Ejemplo para continue

print("\nwhile con la sentencia continue \n")

contador = 0
54
while contador < 10:
contador += 1

if contador == 5:
continue

print("Valor actual de la variable: ", contador)

La función len()

#Función len()

#Opción 1
print("Hola tiene", len("Hola"), "caracteres.")

#Opción 2
longitud = len("La Geekipedia")
print("La Geekipedia tiene", longitud, "caracteres")

Concatenación en Python 3 con el método format()

#Alternativa 1
nombre = "Carlos"
edad = 22

print("Hola {} tienes {} años".format(nombre, edad))

#Alternativa 2
nombre = "Carlos"
edad = 22

print("Hola {nombre} tienes {edad} años".format(nombre = "Carlos", edad = 22))

#Alternativa 3
nombre = "Carlos"
edad = 22

print("Hola {1} tienes {0} años".format(edad, nombre))

Concatenación en Python con f-Strings

#Ejemplo1
print(f"El resultado de la suma de 4 + 1 = {4+1}")

#Ejemplo2
nombre = "Carlos"
estatura = 1.80
55
edad = 22

print(f"Hola {nombre} tienes {edad} años y mides {estatura} centímetros")

#Ejemplo3
nombre = input("¿Cúal es tu nombre?: ")
num_uno = int(input("Introduce un número: "))
num_dos = int(input("Introduce un segundo número: "))

print(f"Hola {nombre} el resultado de {num_uno} + {num_dos} es: {num_uno +

num_dos}")

El método strip()

cadena = "\tHola Ernesto\n"

print(cadena)

cadena = cadena.strip("s tHo\t\n")

print(cadena)

Los métodos rstrip() y lstrip()

#Método rstrip
cadena = "\tHola Ernesto\n"
print(cadena)

cadena = cadena.rstrip("s tHo\t\n")

print(cadena)

#Método lstrip
cadena = "\tHola Ernesto\n"
print(cadena)

cadena = cadena.lstrip("s tHo\t\n")

print(cadena)

Los métodos istitle() y title()

first_name = input("Nombre: ")

last_name = input("Apellido: ")
full_name = f"{first_name} {last_name}"

print()
print(f"¿El formato del método title() se ha aplicado?: {full_name.istitle()}")
print(f"Aplicando el método title(): {full_name.title()}")
print(f"Volvemos a imprimir el nombre: {full_name}")
56
print()
full_name = full_name.title()
print(f"¿El formato del método title() se ha aplicado?: {full_name.istitle()}")
print(f"Se ha aplicado el método title() de manera permanente: {full_name}")

Los métodos islower(), lower(), isupper() y upper()

string = input("Introduce un String:")

print(f"\n¿Todas las letras están en minúsculas?: {string.islower()}")

string = string.lower()
print(f"String en minúsculas: {string}")

print(f"\n¿Todas las letras están en mayúsculas?: {string.isupper()}")

print(f"String en mayúsculas: {string.upper()}")
print(f"String origianl: {string}")

El método swapcase()
txt_lower_upper = "lA gEEKIPEDIA"
print(txt_lower_upper.swapcase())

txt_upper = "CADENA DE MAYÚSCULAS"

print(txt_upper.swapcase())

txt_lower = "cadena con minúsculas"

print(txt_lower.swapcase())

txt_number = "1234!-*"
print(txt_number)

print()
print(txt_lower_upper)
print(txt_upper)
print(txt_lower)
print(txt_number)

El método capitalize()

string = "eL VIAJE eS la RecoMpensa"

print(f"Antes de capitalize(): {string}")

string = string.capitalize()
print(f"Después de capitalize(): {string}")

Los métodos center(), ljust() y rjust()

string = "Menú"

57
print("Métodos con espacios:")
print(string.center(20))
print(string.ljust(20))
print(string.rjust(20))

print("\nMétodos con caracter:")

print(string.center(20, "="))
print(string.ljust(20, "="))
print(string.rjust(20, "="))

print("\nVariable modificada:")
string = string.center(10, "=")
print(string)

El método count()

string = "mi mamá me mima"

contador = 0

print(string.center(40, "="))

contador = string.count("M")
print(f"\nLa letra M se encontró {contador} veces en la cadena: {string}")

contador = string.count("m")
print(f"\nLa letra m se encontró {contador} veces en la cadena: {string}")

contador = string.count("mamá")
print(f"\nLa palabra mamá se encontró {contador} veces en la cadena: {string}")

contador = string.count("me mima")

print(f"\nLa oración me mima se encontró {contador} veces en la cadena: {string}")

contador = string.count("ma")
print(f"\nLa palabra ma se encontró {contador} veces en la cadena: {string}")

contador = string.count("m", 13)

print(f"\nLa letra m se encontró {contador} veces, desde la posición 13 en la cadena:
{string}")

contador = string.count("m", 100)

print(f"\nLa letra m se encontró {contador} veces, desde la posición 100 en la
cadena: {string}")

contador = string.count("m", -3)

print(f"\nLa letra m se encontró {contador} veces, desde la posición -3 en la cadena:
{string}")

contador = string.count("m", 3, 7)
print(f"\nLa letra m se encontró {contador} veces, desde la posición 3 hasta la
58
posición 7 en la cadena: {string}")

contador = string.count("m", 100, 100)

print(f"\nLa letra m se encontró {contador} veces, desde la posición 100 hasta la
posición 100 en la cadena: {string}")

contador = string.count("m", -4, -1)

print(f"\nLa letra m se encontró {contador} veces, desde la posición -4 hasta la
posición -1 en la cadena: {string}")
Los métodos startswith() y endswith()
Los métodos startswith() y endswith()
string = "Diana se peina sola"
resultado = 0
starts_with = "Ejemplos con startswith():"
ends_with = "Ejemplos con endswith():"

print(f"\n{starts_with.rjust(50, '=')}")

resultado = string.startswith("D")
print(f"\n{string} comienza con la subcadena D: {resultado}")

resultado = string.startswith("d")
print(f"\n{string} comienza con la subcadena d: {resultado}")

resultado = string.startswith("Diana")
print(f"\n{string} comienza con la subcadena Diana: {resultado}")

resultado = string.startswith("se", 6)
print(f"\n{string} comienza con la subcadena se, desde la posición 6: {resultado}")

resultado = string.startswith("se", 6, 7)
print(f"\n{string} comienza con la subcadena se, desde la posición 6 hasta la
posición 7: {resultado}")

resultado = string.startswith("se", 100, 100)

print(f"\n{string} comienza con la subcadena se, desde la posición 100 hasta la
posición 100: {resultado}")

resultado = string.startswith("se", -4, -1)

print(f"\n{string} comienza con la subcadena se, desde la posición -4 hasta la
posición -1: {resultado}")

print(f"\n{ends_with.rjust(50, '=')}")

resultado = string.endswith("A")
print(f"\n{string} termina con la subcadena A: {resultado}")

resultado = string.endswith("a")
59
print(f"\n{string} termina con la subcadena a: {resultado}")

resultado = string.endswith("sola")
print(f"\n{string} termina con la subcadena sola: {resultado}")

resultado = string.endswith("sola", 10)

print(f"\n{string} termina con la subcadena sola, desde la posición 10: {resultado}")

resultado = string.endswith("s", 9, 14)

print(f"\n{string} termina con la subcadena s, desde la posición 9 hasta la posición
14: {resultado}")

resultado = string.endswith("s", 100, 100)

print(f"\n{string} termina con la subcadena s, desde la posición 100 hasta la posición
100: {resultado}")

resultado = string.endswith("s", -4, -2)

print(f"\n{string} termina con la subcadena s, desde la posición -4 hasta la posición
-2: {resultado}")

Substrings
string = "0123456789"
substring = ""

print(f"Cadena principal: {string}")

substring = string[0]
print(f"\nSubcadena con indice en la posición [0] es: {substring}")

substring = string[5]
print(f"\nSubcadena con indice en la posición [5] es: {substring}")

substring = string[-4]
print(f"\nSubcadena con indice en la posición [-4] es: {substring}")

substring = string[0:3]
print(f"\nSubcadena con indices en las posiciones [0:3] es: {substring}")

substring = string[:3]
print(f"\nSubcadena con indices en las posiciones [:3] es: {substring}")

substring = string[5:]
print(f"\nSubcadena con indices en las posiciones [5:] es: {substring}")

substring = string[-4:-1]
print(f"\nSubcadena con indices en las posiciones [-4:-1] es: {substring}")

substring = string[:]
print(f"\nSubcadena con indices en las posiciones [:] es: {substring}")

60
substring = string[1:6:2]
print(f"\nSubcadena con indices en las posiciones y salto [1:6:2] es: {substring}")

substring = string[::3]
print(f"\nSubcadena con indices en las posiciones y salto [::3] es: {substring}")

Ejercicio práctico (Eliminar una palabra)

string = input("Introduce una frase: ")
palabra = input("Introduce la palabra que deseas eliminar: ")
substring = ""

indice = string.find(palabra)
substring = string[0 : indice] + string[indice + len(palabra) + 1 : ]

print(f"Cadena resultante: {substring}")

El ciclo o bucle for

string = "Hola"

for character in string:

print(character)

print("Fin del programa.")

# Ejemplo bucle for

for i in [1, 2, 3, 4]:
print(i, end=", ") # prints: 1, 2, 3, 4,

# Ejemplo más complejo

for i in [1, 3, 5, 7, 9]:
x = i**2 - (i-1)*(i+1)
print(x, end=", ") # prints 1, 1, 1, 1, 1,

La sentencia for forma un bucle definido que recorre los elementos de una colección
de datos o una secuencia ordenada como listas, diccionarios, tuplas, strings, etc. El
bucle hará tantas iteraciones cuántos elementos hay en la secuencia.
61
El bucle for en Python tiene la siguiente sintaxis:

for <variable> in <secuencia>:

<bloque de código>

Por ejemplo, para iterar los elementos de la lista “idiomas” con un bucle for, se le
asigna el nombre “idioma” a una variable que representará los elementos de la lista
en cada repetición.

idiomas = ['Árabe', 'Inglés', 'Francés', 'Español']

índice = 0
for idioma in idiomas:
print ('Este idioma está en la lista: ' + idiomas[índice])
índice += 1

El bucle for con cadenas tipo string funciona de la misma manera, pero con
caracteres en lugar de elementos:

cadena = 'Python'
for carácter in cadena:
print(carácter)

Igual que con el bucle while, se puede usar la sentencia else para agregar una
acción adicional al finalizar el bucle. Veamos un ejemplo con la función range():

for x in range(5):
print(x)
else:
print('Fin del bucle')

Bucles anidados
Python permite anidar bucles metiendo uno dentro de otro. Esto puede ser útil para
resolver problemas más complejos: por ejemplo, si quieres iterar algún objeto donde
cada elemento tiene otra clase iterable como una lista de listas.

lista = [[1, 2, 3],

[4, 5, 6],
[7, 8, 9]]

for a in lista:
for b in a:
print(b)

De la misma forma puedes anidar un bucle while. Por ejemplo, te puede ayudar si
quieres generar todas las combinaciones posibles de dos números:

a=0
b=0
while a < 3:
62
while b < 3:
print(a,b)
b += 1
a += 1
b=0

Usando ciertas instrucciones, puedes interrumpir el flujo de ejecución de un bucle

si lo necesitas. La sentencia break “rompe” el bucle en cualquier momento, aun
cuando la condición sigue siendo verdadera. En el siguiente ejemplo el bucle for
recorre todos los números del rango del 0 al 4, pero el programa finaliza cuando el
número tenga el valor de 3:

for x in range(5):
if x == 3:
break
print (x)

Lo mismo pasa con el bucle while: al recibir una entrada determinada, el programa
sale del bucle y procede a la siguiente línea del código:

while True:
respuesta = input('> ')
if respuesta == 'salir':
break
else:
print(respuesta)
print ('¡Adiós!')

La sentencia continue termina la iteración corriente sin tomar en cuenta el código

que está debajo y se vuelve al inicio del bucle.

x=0
while x < 5:
x += 1
if x == 3:
continue
print(x)

En el ejemplo abajo, cuando el valor llegue a ‘y’, el programa saltará de nuevo al

bucle for sin ejecutar la última línea de print y sin salir del bucle:

for carácter in 'Python':

if carácter == 'y':
continue
print ('La letra es:', carácter)

Por último, cabe mencionar la sentencia pass. Cuando la ejecución de un bucle

llega a la sentencia pass, simplemente pasa a la siguiente instrucción sin modificar
el flujo establecido. Habitualmente, se utiliza para reservar espacio si en el momento
63
de escribir un código hay una parte que todavía no está completada:

for x in range(1, 5):

if x == 2:
pass
print (x)

La función range() en Python

La función range() proporciona una secuencia de enteros basada en los argumentos
de la función. Se puede encontrar información adicional en la documentación de
Python para la función range().

range(parar)
range(incio, parar[, paso])

El argumento inicio es el primer valor del rango. Si se llama a range() con un solo
argumento, Python asume inicio = 0.
El argumento parar es el límite superior del rango. Es importante tener en cuenta
que este valor superior no está incluido en el rango.
En el ejemplo a continuación, tenemos un rango que comienza en el valor
predeterminado de 0 e incluye enteros menores que 5.

# Ejemplo con un argumento

for i in range(5):
print(i, end=", ") # prints: 0, 1, 2, 3, 4,

En nuestro siguiente ejemplo, establecemos inicio = -1 y de nuevo incluimos

enteros menores que 5.

# Ejemplo con dos argumentos

for i in range(-1, 5):
print(i, end=", ") # prints: -1, 0, 1, 2, 3, 4,

El valor de paso opcional controla el incremento entre los valores del rango. De
forma predeterminada, paso = 1.
En nuestro ejemplo final, usamos el rango de enteros de -1 a 5 y establecemos
paso = 2.
# Ejemplo con tres argumentos
for i in range(-1, 5, 2):
print(i, end=", ") # prints: -1, 1, 3,

Bucle while
Una forma de iteración en Python es la sentencia while que permite repetir la
ejecución de un bloque de código siempre y cuando la condición del bucle sea
verdadera.
La sintaxis es muy simple:
1 while <condición>:
2 <bloque de código>
64
 El código del cuerpo del bucle debe cambiar una o más variables hasta que la
condición resulte falsa y el bucle termine. En este ejemplo la variable de iteración
cambia el valor del parámetro cada vez que se ejecuta el ciclo y controla cuándo
finaliza el ciclo.

x=5
while x > 0:
x -= 1
print(x)
print('¡Pum!')

x=5
while x > 0:
x -= 1
print(x)
else:
print('Fin del bucle')

x=5
while x > 0:
print('¡Al infinito y más allá!')

How Python Programmers Used to Simulate Switch Case

There were multiple ways Pythonistas simulated switch statements back in the day.
Using a function and the elif keyword was one of them and you can do it this way:

def switch(lang):
if lang == "JavaScript":
return "You can become a web developer."
elif lang == "PHP":
return "You can become a backend developer."
elif lang == "Python":
return "You can become a Data Scientist"
elif lang == "Solidity":
return "You can become a Blockchain developer."
elif lang == "Java":
return "You can become a mobile app developer"

print(switch("JavaScript"))
print(switch("PHP"))
print(switch("Java"))

Otro ejemplo:
lang = input("What's the programming language you want to learn? ")

match lang:
case "JavaScript":
print("You can become a web developer.")
65
case "Python":
print("You can become a Data Scientist")

case "PHP":
print("You can become a backend developer")

case "Solidity":
print("You can become a Blockchain developer")

case "Java":
print("You can become a mobile app developer")
case _:
print("The language doesn't matter, what matters is solving problems.")

66
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 14/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Las listas enlazadas, las pilas y las colas son colecciones de elementos de datos
“alineados en una fila”; mientras que los árboles son estructuras de datos que
almacenan sus nodos de forma jerárquica. En la Figura 1 se pueden apreciar las
estructuras lineales, como las listas, y un árbol, que es una estructura no lineal.

Figura 1. Representación gráfica de la diferencia entre las estructuras de datos

lineales y las no lineales.

Estructuras de datos lineales

Las listas, las pilas y las colas son colecciones lineales (es decir, secuencias) de
elementos de datos del mismo tipo.
En las listas los usuarios pueden insertar y eliminar elementos en cualquier parte
de ellas; mientras que, en las pilas y colas se tienen restricciones en la inserción y
eliminación de elementos.
Las pilas son conocidas como estructuras de datos LIFO (Last In First Out; último
en entrar, primero en salir) esto es, el elemento más reciente en ser añadido será el
primero en ser removido.

67
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 15/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

En las colas, los nodos se remueven de la estructura en el mismo orden en el que

se agregan; por esta razón se les conoce como estructuras de datos tipo FIFO (First
In First Out; primero en entrar, primero en salir).

Estructuras de datos no lineales

También conocidas como árboles, son estructuras de datos bidimensionales no

lineales, con propiedades especiales; los nodos de un árbol contienen dos o más
enlaces.

El nodo raíz es el primer nodo en un árbol. Cada enlace en el nodo raíz hace
referencia a un hijo. En la Figura 1, el nodo raíz es A. Un nodo es padre de otro si
existe un enlace desde el primer nodo al segundo (en ese caso, también decimos
que el segundo nodo es hijo del primero). Por ejemplo, en la Figura 1 el nodo B es
padre de E.

A un nodo que no tiene hijos se le llama hoja, como los nodos D, E, F, G e I de la

Figura 1.

Figura 2. Tipos de árboles.

68
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 16/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Un árbol binario es aquel en el que cada nodo tiene máximo dos hijos; mientras que
un árbol binario de búsqueda es un árbol binario en el que para cada nodo “n”, el
nodo a la izquierda (“i”) de “n” debe satisfacer: i≤n; mientras que el nodo a la derecha
de (“d”) “n” se debe cumplir que n<d. Esto debe satisfacerse para todo nodo “n”. En
la Figura 2 se muestra un árbol binario y un árbol binario de búsqueda; el árbol
mostrado en la Figura 2 b), no es de búsqueda debido a que “12” no está a la
derecha de “8”.

Las operaciones básicas en árboles son: insertar y localizar elementos, así como
recorrer y moverse a través del árbol.

Con ayuda de los árboles se pueden representar datos jerárquicos y facilitar las
operaciones de búsqueda en estos conjuntos de datos. Un ejemplo del uso de
árboles es el manejo de carpetas de archivos en un sistema operativo.

Algoritmos de ordenación y búsqueda

Una vez que se tiene un grupo de datos almacenados en una estructura de datos,
o en un archivo, se pueden ordenar siguiendo algún criterio. Ordenar es el proceso
de reorganizar un conjunto de objetos en una secuencia determinada; este proceso
generalmente tiene como objetivo facilitar la búsqueda de elementos pertenecientes
a un conjunto.

Los métodos de ordenación, para estructuras lineales, se suelen dividir en dos

grandes grupos:

 Directos: Intercambio, burbuja, selección, inserción.

 Indirectos o avanzados: Shell, quicksort, ordenación por mezcla, radixsort.

A la localización de un elemento dentro de la estructura de datos, o determinar si

este elemento se encuentra dentro del conjunto de datos, se le conoce como
búsqueda. Para encontrar elementos dentro de una estructura de datos lineal se
pueden usar los métodos de búsqueda secuencial o búsqueda binaria.

Para los árboles, los métodos de búsqueda son informados y no informados (a

ciegas, ya que recorre todo el árbol sin tener una pista de donde pueda estar el dato
deseado).

69
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 17/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

4. Material y equipo

Computadora

5. Desarrollo

Actividad 1. Implementación de estructuras de datos

Listas (arrays, arreglos o vectores) en Python. Uso y creación de listas en

Python

Las listas en Python forman parte de lo que se conoce como estructuras de datos que nos ofrece Python
(son un tipo de array). En otros lenguajes de programación, se los conoce como vectores.

Las listas, son una estructura de datos de vital importancia, pues son útiles para resolver múltiples
problemas que nunca podríamos solucionar sin ellas. Las listas en Python son utilizadas para almacenar
múltiples valores en una única variable. Esto puede parecer innecesario, pero en realidad resuelve muchos
desafíos. Veamos.

En múltiples ocasiones es necesario almacenar gran cantidad de información en una variable y a menudo
sucede que no conocemos con exactitud la cantidad de datos que debemos almacenar en ella. Sin
embargo, sabemos que sí sería más de uno, como por ejemplo almacenar los nombres de las personas
ingresadas en tu programa. En este caso, las listas nos permiten solucionar este tipo de problemas, pues en
una misma lista podremos almacenar todos esos valores, sin importar cuántos sean.

70
 ¿Cómo declarar una lista en Python?

Para declarar una lista en Python, se deben seguir las mismas normas básicas que se siguen para declarar
una variable cualquiera, con un pequeño cambio en la sintaxis:

nombre_de_la_lista = []

otra_lista = list()

Todo muy claro, excepto por los "[]" o el uso de list(). Creamos una lista con un nombre cualquiera
(nombre_de_la_lista u otra_lista) y le asignamos inicialmente una lista vacía. Sí, así es los corchetes "[]"
sin nada en su interior crear una lista vacía. De hecho, al usar list(), sin poner nada entre los paréntesis,
obtenemos lo mismo.

Una vez la lista es creada, podemos agregarle elementos, quitarlos, obtenerlos, y varias cosas más. Sin
embargo, también podemos crear listas con elementos en su interior desde el comienzo.

lista_con_elementos = [1, 2, True, 'Hola', 5.8]

otra_lista_con_elementos = list([4, 9, False, 'texto'])

Como puedes ver, al poner valores entre corchetes "[]" y separados por comas, estarás indicando los
elementos para tus listas. Cabe resaltar también que puedes agregar elementos mixtos, es decir, pueden
ser de cualquier tipo de dato (texto, booleanos, números, etc.).

Ya tenemos claro cómo declarar una lista en Python. Sin embargo, aún no sabemos cómo obtener los
elementos de esa lista, es decir, una vez dicha lista tiene los elementos que queremos, cómo podemos
obtener esa información y más aún, cómo obtener un elemento específico dentro de esa lista. Veámoslo:

Obtener el valor de un elemento de una lista en Python

Es muy común el caso en el que tenemos una lista con una enorme cantidad de elementos, sin embargo,
de todos esos elementos solo nos interesa uno en especial y corremos con la suerte de saber cuál es su
valor o mejor aún su posición específica dentro de la lista.

mi_lista = ['Juan', 'Pedro', 'Laura', 'Carmen', 'Susana']

print(mi_lista[0]) # Muestra Juan (la primera posición es la 0)
print(mi_lista[-1]) # Muestra Susana
print(mi_lista[1]) # Muestra Pedro
print(mi_lista[2]) # Muestra Laura
print(mi_lista[-2]) # Muestra Carmen

Acá hay varias cosas por entender. Así que veámoslas de una en una:

1. Puedes acceder a una posición usando el nombre de la variable y corchetes "[]" indicando en su
interior el índice que quieres obtener.
71
 2. Las posiciones de las listas arrancan enumeradas desde cero, así la primera posición se accede
como [0] y la última sería el tamaño total menos 1
3. Se pueden usar índices negativos, así accediendo a los elementos de la lista contando dese atrás.
Así un modo sencillo de obtener el último elemento es con [-1]
4. Si accedes a un índice que no existe, el programa fallará.

Recorrer una lista en Python

En este caso, los ciclos vienen de gran ayuda. El caso general, sería hacerlo por medio de un ciclo for que
vaya accediendo uno por uno a los elementos o incluso aumentando de uno en uno el índice que queremos
acceder de la lista.

edades = [20, 41, 6, 18, 23]

# Recorriendo los elementos

for edad in edades:
print(edad)

# Recorriendo los índices

for i in range(len(edaded)):
print(edaded[i])

# Con while y los índices

indice = 0

while indice < len(edaded):

print(edades[indice])
indice += 1

Como puedes ver, el ciclo for puede acceder directamente a los elementos y recorrerlos uno por uno. Sin
embargo, a veces puedes necesitar los índices y también puedes acceder a cada elemento por medio de ese
índice ya sea usando un ciclo for o incluso un while con un contador.

Ahora que sabemos cómo acceder a las posiciones y cómo recorrer una lista en Python, veamos cómo se
pueden agregar (append()) y remover (pop() o remove()) elementos de uan lista.

Cómo agregar y remover elementos a una lista en Python

Hay muchas operaciones que se pueden llevar a cabo con las listas en Python. Sin embargo, las más
importantes son agregar y remover, elementos de la misma, así que veamos cómo hacerlo.

Agregado elementos a una lista con append() en Python

Como indico, se puede usar la función append de las listas para agregar un elemento.

números = []

números.append(10)
72
números.append(5)
números.append(3)

print(números)
# Mostrará [10, 5, 3]

Como ves, con cada llamada a append(), podrás agregar un nuevo elemento, de cualquier tipo a la lista.
Sin embargo, hay otro modo de hacerlo, creando una nueva lista con los nuevos elementos.

Uniendo listas en Python

Hay otro modo de agregar elementos a una lista y es básicamente uniendo la lista existente con una
nueva. De ese modo, podría evitar llamar a append() varias veces, sino unir todo de una sola vez. Así
sería el ejemplo anterior, simplificado

números = []
# Unimos la lista anterior con una nueva
números = números + [10, 5, 3]
print(números)
# Mostrará [10, 5, 3]
Removiendo un elemento de una lista con pop() en Python

La función pop, removerá un elemento según el índice que se indique.

palabras = ['hola', 'hello', 'ola']

palabras.pop(1)

print(palabras)
# Mostrará ['hola', 'ola']

Notar que acá debes indicar la posición del elemento en la lista. Esa posición debe existir, o sino fallará.
También puedes usar índices negativos.

Ahora, si no conoces la posición, puedes usar el valor que deseas borrar. Veamos:

Removiendo un elemento de una lista con remove() en Python

La función remove, removerá un elemento según el valor que este tenga al interior de la lista.

palabras = ['hola', 'hello', 'hello', 'ola']

palabras.remove('hello')

print(palabras)
# Mostrará ['hola', 'hello', 'ola']

73
Hay cosas interesantes acá. Primero, remove buscará por ti el elemento y lo borrará. Sin
embargo, solo borrará el primero que encuentra, no todos ellos. Por lo tanto, dado que "hello"
estaba dos veces en nuestra lista, solo removió el primero.
Ejemplo de listas en Python

El problema es simple, queremos crear un programa con el cual podamos guardar los nombres y las
identificaciones de múltiples personas (no sabemos cuántas) sin perder ninguna de ellas. El usuario es el
encargado de suministrar la información de cada persona. Vamos a suponer que el usuario solo podrá
ingresar un máximo de tres personas, para así poder comprobar fácilmente nuestro programa. Sin
embargo, puedes hacerlo sin límite si prefieres:

# Creamos las listas (vacías al comienzo)

nombres = []
identificaciones = []

# Definimos un tamaño para las listas

# Lo puedes cambiar si quieres
tamaño = 3

# Leemos los datos y los agregamos a la lista

for i in range(tamaño):
print("Ingrese los datos de la persona", i + 1)
nombre = input("Nombre: ")
identificación = input("Identificación: ")

nombres.append(nombre)
identificaciones.append(identificación)

# Ahora mostremos las listas

for i in range(tamaño):
print("Mostrando los datos de la persona", i + 1)

print("Nombre:", nombres[i])
print("Identificación:", identificaciones[i])

Tablas (matrices o listas de listas) en Python. Uso y creación de tablas en

Python

Las tablas en Python forman parte de lo que se conoce como estructuras de datos que nos ofrece Python.
Cabe resaltar que, si has programado en otros lenguajes, las tablas no son más que lo que se conoce como
matrices o listas de listas en otros lenguajes de programación.

Las tablas, son una estructura de datos de vital importancia, pues son útiles para resolver múltiples
problemas que no podríamos solucionar sin ellas. Las tablas son utilizadas para almacenar múltiples
valores en una única variable. De hecho, al final se trata de una lista que contiene otras listas en su
interior.

74
En general, la lógica es la misma que se maneja en las listas y su propósito es el mismo. Sin embargo, las
tablas en Python van un poco más allá, pues en esencia te dan múltiples niveles más de "anidamiento",
teniendo así listas al interior de otras. No nos vamos a detener mucho en el proceso, pues la lógica es
bastante similar.

Ejemplo de tablas en Python

Imaginemos que queremos crear un programa con el cual podamos de algún modo almacenar los nombres
e identificaciones de diferentes personas. De hecho, este mismo ejemplo, lo vismos en el artículo sobre
listas. Pues en esta ocasión, vamos a resolverlo usando solo una lista, la cual a su vez contendrá otras dos
(creando así una tabla). Una con los nombres y otra con las identificaciones. Analicemos el problema y
aprendamos a usar tablas en Python:

Usando tablas en Python:

¡Pues bien!, Las tablas o las matrices han venido para ayudarnos en múltiples circunstancias similares a
las del ejemplo. Dado que una lista es capaz de almacenar múltiples listas en su interior, la converimos en
una tabla (con filas y columnas) y asignamos valores en cada casilla según requerimos, indicando la fila y
la columna correspondientes.

Muy bien, ahora que sabemos la gran utilidad de las tablas, listas de listas o matrices para nosotros,
aprendamos más acerca de ellas, veamos cómo crear una tabla, cómo recorrerlas y algunos ejemplos de
esto.

¿Cómo crear una tabla en Python?

Para declarar una tabla en Python, se deben seguir las mismas normas básicas que se siguen para declarar
una lista, teniendo en cuenta que contendrá listas en su interior:

nombre_de_la_tabla = []

# También puedes iniciar la listas en el interior

nombre_de_la_tabla = [[], []]

Una vez la tabla es creada, podemos agregarle elementos, quitarlos, obtenerlos, y varias cosas más, tal
como hacemos con la listas tradicionales.

Ya tenemos claro cómo declarar una tabla en Python. Sin embargo, aún no sabemos cómo obtener los
elementos de esa tabla, es decir, una vez dicha tabla tiene los elementos que queremos, cómo podemos
obtener esa información y más aún, cómo obtener un elemento específico dentro de esa tabla. Veámoslo:

Obtener el valor de un elemento de una tabla en Python

Es muy común el caso en el que tenemos una tabla con una enorme cantidad de elementos,
sin embargo, de todos esos elementos solo nos interesa uno en especial y corremos con la
suerte de saber cuál es su valor o mejor aún su posición específica dentro de la tabla. Con
posición me refiero a la fila y a la columna. Es decir la lista que contiene el elemento en su
interior (fila) y luego el elemento específico en esa lista (columna).

75
mi_tabla = [['Juan', 'Laura'], [21, 32]]

# Muestra Juan (la primera posición es la 0, 0)

print(mi_tabla[0][0])

# Muestra 32 (última fila, segunda columna)

print(mi_tabla[-1][1])

# Muestra 21
print(mi_tabla[1][0])

# Muestra Laura
print(mi_tabla[0][1])

# Muestra la lista con nombres

print(mi_tabla[0])

Acá hay varias cosas por entender. Así que veámoslas de una en una:

1. Puedes acceder a una posición usando el nombre de la variable y corchetes "[]" indicando en su
interior el índice que quieres obtener.
2. Ahora se usan corchetes para cada lista. El primer conjunto de corchetes accede a la lista, el
segundo a una posición de esa lista.

Ya tenemos entonces una forma de acceder de forma individual a un elemento de una tabla en Python,
vamos a ver ahora como obtener todos los elementos de una tabla, recorriendo uno a uno:

Recorrer una tabla en Python

En este caso, los ciclos vienen de gran ayuda. El caso general, sería hacerlo por medio de un
ciclo for que vaya accediendo uno por uno a los elementos o incluso aumentando de uno en
uno el índice que queremos acceder de la tabla, tanto para la fila como para la columna.
mi_tabla = [['Juan', 'Laura'], [21, 32]]

# Recorriendo los elementos

# Accedemos a cada fila (que es una lista)

for fila in mi_tabla:
# Accedemos a cada columna dentro de la fila
for columna in fila:
print(columna)

# Recorriendo los índices

# i serían las filas
for i in range(len(mi_tabla)):
for j in range(len(mi_tabla[i])):
print(mi_tabla[i][j])

76
# Con while y los índices
fila = 0

while fila < len(mi_tabla):

columna = 0
while columna < len(mi_tabla[fila]):
print(mi_tabla[fila][columna])
columna += 1
fila += 1

Como puedes ver, el ciclo for puede acceder directamente a los elementos y recorrerlos uno por uno. Sin
embargo, a veces puedes necesitar los índices y también puedes acceder a cada elemento por medio de ese
índice ya sea usando un ciclo for o incluso un while con un contador.

Como imaginarás, al ser simplemente listas con listas en su interior, seguirás teniendo acceso a las
mismas funciones para agregar, buscar y eliminar elementos, así que hagamos uso de todo ello para
resolver el ejercicio que planteamos al comienzo.

Ejemplo de tablas en Python

El problema es simple, queremos crear un programa con el cual podamos guardar los nombres
y las identificaciones de múltiples personas (no sabemos cuántas) sin perder ninguna de ellas.
El usuario es el encargado de suministrar la información de cada persona. Vamos a suponer
que el usuario solo podrá ingresar un máximo de tres personas, para así poder comprobar
fácilmente nuestro programa. Sin embargo, puedes hacerlo sin límite si prefieres:

# Creamos la tabla con listas vacías al comienzo

usuarios = [[], []]

# Definimos un tamaño para las listas de la tabla

# Lo puedes cambiar si quieres
tamaño = 3

# Leemos los datos y los agregamos a la tabla

for i in range(tamaño):
print("Ingrese los datos de la persona", i + 1)
nombre = input("Nombre: ")
identificación = input("Identificación: ")

# La primera lista es para los nombres

usuarios[0].append(nombre)

# La segunda lista es para las identificaciones

usuarios[1].append(identificación)

# Ahora mostremos los valores en la tabla

for i in range(tamaño):
print("Mostrando los datos de la persona", i + 1)

77
 print("Nombre:", usuarios[0][i])
print("Identificación:", usuarios[1][i])

Diccionarios (listas asociativas) en Python. Uso y creación de diccionarios en

Python

Los diccionarios en Python forman parte de lo que se conoce como estructuras de datos que nos ofrece
Python. Cabe resaltar que, si has programado en otros lenguajes, los diccionarios no son más que listas
asociativas o listas con llaves, donde cada llave es un identificador único de una posición de la lista.
Básicamente, en lugar de usar números de 0 a N, se usan llaves que pueden ser strings generalmente.

En general, la lógica es la misma que se maneja en las listas y su propósito es el mismo. Sin embargo, los
diccionarios en Python nos permiten organizar e identificar de manera única las posiciones de la lista,
usando lo que se conoce como llaves.

Ejemplo de diccionarios en Python

Imaginemos que queremos crear un programa con el cual podamos de algún modo almacenar los nombres
e identificaciones de diferentes personas. De hecho, una vez más, este mismo ejemplo lo vimos en los
artículos anteriores. Pero esta vez, lo vamos a resolver usando diccionarios, lo cual nos permitirá crear
una solución más fácil de entender y leer. Analicemos el problema y aprendamos a usar diccionarios en
Python:

Usando diccionarios en Python:

Los diccionarios o listas asociativas, nos permitirán crear una lista indicando nombres únicos y fáciles de
recordar y asociar en nuestro código. Un diccionario puede almacenar múltiples elementos en su interior,
lo cual incluye otros diccionarios o listas o datos primitivos.

Muy bien, ahora que sabemos la gran utilidad de los diccionarios, aprendamos más acerca de ellos,
veamos cómo crear un diccionario, cómo recorrerlos y algunos ejemplos de esto.

¿Cómo crear un diccionario en Python?

Para declarar un diccionario en Python, se deben seguir las mismas normas básicas que se siguen para
declarar una lista, PERO en lugar de usar corchetes "[]" usaremos llaves "{}" para declararlos:

nombre_del_diccionario = {}

otro_diccionario = {
"nombre": "Alberto",
"usuario": "alb_123",
}

Una vez el diccionario es creado, podemos agregarle elementos, quitarlos, obtenerlos, y varias
cosas más, tal como hacemos con las listas (usando los mismos métodos).

78
 Obtener el valor de un elemento de un diccionario en Python

Es muy común el caso en el que tenemos un diccionario con una enorme cantidad de elementos, sin
embargo, de todos esos elementos solo nos interesa uno en especial y corremos con la suerte de saber cuál
es su valor o mejor aún su llave específica dentro del diccionario.

mi_diccionario = {
"nombre": "Juan",
"usuario": "jn123",
}

# Muestra Juan
print(mi_diccionario["nombre"])

# Muestra jn123
print(mi_diccionario["usuario"])

En esencia, la manera de acceder es la misma que se usaba en las listas, es decir, usando
corchetes "[]". Sin embargo, ahora en lugar de indicar un índice numérico, indicas la llave del
diccionario.

Ya tenemos entonces una forma de acceder a un elemento de un diccionario en Python, vamos

a ver ahora cómo obtener todos los elementos de un diccionario, recorriendo uno a uno:

Recorrer un diccionario en Python

En este caso, los ciclos vienen de gran ayuda. El caso general, sería hacerlo por medio de un ciclo for que
vaya accediendo uno por uno a los elementos o incluso aumentando de uno en uno el índice que queremos
acceder del diccionario, tanto para la fila como para la columna.

mi_diccionario = {
"nombre": "Juan",
"edad": "23",
"usuario": "jn23",
}

# Recorriendo los elementos

for llave in mi_diccionario:

print(llave, ": ", mi_diccionario[llave], sep='')

Como puedes ver, con el ciclo for puede recorrer una por una las llaves del diccionario y luego usar esa
llave para mostrar el valor asignado a la misma dentro del diccionario.

Veamos ahora cómo resolver el problema que planteamos al comienzo, usando diccionarios en Python.

79
 Ejemplo de diccionarios en Python

El problema es simple, queremos crear un programa con el cual podamos guardar los nombres y las
identificaciones de múltiples personas (no sabemos cuántas) sin perder ninguna de ellas. El usuario es el
encargado de suministrar la información de cada persona. Vamos a suponer que el usuario solo podrá
ingresar un máximo de tres personas, para así poder comprobar fácilmente nuestro programa. Sin
embargo, puedes hacerlo sin límite si prefieres:

# Creamos el diccionario con listas vacías en su interior

usuarios = {
"nombres": [],
"identificaciones": []
}

# Definimos un tamaño para las listas del diccionario

# Lo puedes cambiar si quieres
tamaño = 3

# Leemos los datos y los agregamos a el diccionario

for i in range(tamaño):
print("Ingrese los datos de la persona", i + 1)
nombre = input("Nombre: ")
identificación = input("Identificación: ")

# La primera lista es para los nombres

usuarios["nombres"].append(nombre)

# La segunda lista es para las identificaciones

usuarios["identificaciones"].append(identificación)

# Ahora mostremos los valores en el diccionario

for i in range(tamaño):
print("Mostrando los datos de la persona", i + 1)

print("Nombre:", usuarios["nombres"][i])
print("Identificación:", usuarios["identificaciones"][i])

Realizar un programa en el que se empleen al menos dos estructuras de datos de

diferente tipo para generar registros de datos de algún tipo de objeto, utilizando al
menos 3 operaciones fundamentales de cada estructura usada.

5.1.- Implemente un proyecto llamado ColaObjetos como sigue:

class Cola:
def __init__(self):
self.items = []

80
 def estaVacia(self):
return self.items == []

def agregar(self, item):

self.items.insert(0,item)

def avanzar(self):
return self.items.pop()

def tamano(self):
return len(self.items)

c=Cola()
c.agregar(4)
c.agregar('perro')
c.agregar(True)
print(c.tamano())

Para finalizar el programa imprime los datos de las personas recorriendo la pila.

class Pila:
def __init__(self):
self.items = []

def estaVacia(self):
return self.items == []

def incluir(self, item):

self.items.insert(0,item)

def extraer(self):
return self.items.pop(0)

def inspeccionar(self):
return self.items[0]

def tamano(self):
return len(self.items)

s = Pila()
s.incluir('hola')
s.incluir('verdadero')
print(s.extraer())

81
 Actividad 2. Algoritmo de Ordenación

Ordenar los datos guardados en una estructura generada en la Actividad 1 mediante

alguno de los métodos de ordenación, conforme a dos criterios distintos.

1. Método de Ordenamiento de Inserción directa en PYTHON

def ordenamientoPorInsercion(unaLista):
for indice in range(1,len(unaLista)):

valorActual = unaLista[indice]
posicion = indice

while posicion>0 and unaLista[posicion-1]>valorActual:

unaLista[posicion]=unaLista[posicion-1]
posicion = posicion-1

unaLista[posicion]=valorActual

unaLista = [54,26,93,17,77,31,44,55,20]
ordenamientoPorInsercion(unaLista)
print(unaLista)

82
 Método de Ordenamiento Shell Sort en C#

def ordenamientoDeShell(unaLista):
contadorSublistas = len(unaLista)//2
while contadorSublistas > 0:

for posicionInicio in range(contadorSublistas):

brechaOrdenamientoPorInsercion(unaLista,posicionInicio,contad
orSublistas)

print("Después de los incrementos de

tamaño",contadorSublistas,
83
 "La lista es",unaLista)

contadorSublistas = contadorSublistas // 2

def brechaOrdenamientoPorInsercion(unaLista,inicio,brecha):
for i in range(inicio+brecha,len(unaLista),brecha):

valorActual = unaLista[i]
posicion = i

while posicion>=brecha and unaLista[posicion-

brecha]>valorActual:
unaLista[posicion]=unaLista[posicion-brecha]
posicion = posicion-brecha

unaLista[posicion]=valorActual

unaLista = [54,26,93,17,77,31,44,55,20]
ordenamientoDeShell(unaLista)
print(unaLista)

Método de Ordenamiento Quick Sort en C#

Elegiremos un pivote (en este caso, el primer elemento de la lista) y

cambiaremos su posición con el elemento en el medio; Repasemos
toda la lista y verifiquemos elemento por elemento, comparándolos con
el pivote. A partir de entonces: Si el ítem está en una posición más baja
que el pivote en orden alfabético, será transferido o mantenido en la
lista de la izquierda; Si el elemento está en una posición superior al
pivote en orden alfabético, se transferirá o se mantendrá en la lista de
la derecha. Haciendo esto recursivamente, al final tendremos una lista
ordenada:

numeros = [5,4,3,2,1]

def QuickSort(numeros, izq, der):

pivote = numeros[izq]
i = izq
j = der
aux = 0

while i < j:
while numeros[i] <= pivote and i < j:
i += 1

while numeros[j] > pivote:

j -= 1

if i < j:
84
 aux = numeros[i]
numeros[i] = numeros[j]
numeros[j] = aux

numeros[izq] = numeros[j]
numeros[j] = pivote

if izq < j-1:

QuickSort(numeros,izq,j-1)

if j+1 < der:

QuickSort(numeros,j+1,der)

QuickSort(numeros,0,len(numeros) - 1)
print(numeros)

85
 Método de Ordenamiento Burbuja en PYTHON

def ordenamientoBurbuja(unaLista):
for numPasada in range(len(unaLista)-1,0,-1):
for i in range(numPasada):
if unaLista[i]>unaLista[i+1]:
temp = unaLista[i]
unaLista[i] = unaLista[i+1]
unaLista[i+1] = temp

unaLista = [54,26,93,17,77,31,44,55,20]
ordenamientoBurbuja(unaLista)
print(unaLista)

86
Método de Ordenamiento Merge Sort

87
def ordenamientoPorMezcla(unaLista):
print("Dividir ",unaLista)
if len(unaLista)>1:
mitad = len(unaLista)//2
mitadIzquierda = unaLista[:mitad]
mitadDerecha = unaLista[mitad:]

ordenamientoPorMezcla(mitadIzquierda)
ordenamientoPorMezcla(mitadDerecha)

i=0
j=0
k=0
while i < len(mitadIzquierda) and j < len(mitadDerecha):
if mitadIzquierda[i] < mitadDerecha[j]:
unaLista[k]=mitadIzquierda[i]
i=i+1
else:
unaLista[k]=mitadDerecha[j]
j=j+1
k=k+1

while i < len(mitadIzquierda):

unaLista[k]=mitadIzquierda[i]
i=i+1
k=k+1

while j < len(mitadDerecha):

unaLista[k]=mitadDerecha[j]
j=j+1
k=k+1
print("Mezclar ",unaLista)

unaLista = [54,26,93,17,77,31,44,55,20]
ordenamientoPorMezcla(unaLista)
print(unaLista)

Actividad 3. Algoritmo de Búsqueda

Partiendo de una estructura de datos generada en la Actividad 1, realizar diferentes

búsquedas, mediante al menos dos métodos, y comparar el número de iteraciones
realizadas por cada método para llegar al resultado.

Búsqueda Binaria en C#
El algoritmo de búsqueda binaria es un excelente método para buscar datos dentro de una
estructura(generalmente un arreglo unidimensional). Se le da el nombre de búsqueda binaria
por que el algoritmo divide en dos el arreglo, aludiendo al concepto de bit, el cual puede tener
dos estados.
La única condición para usar este algoritmo es que los datos dentro del arreglo estén
88
ordenados de menor a mayor.
La solución mas fácil para realizar una búsqueda es por fuerza bruta, pero este método puede
resultar bastante ineficiente cuando se tiene una gran cantidad de datos, ya que habría que
buscar posición por posición hasta encontrar el dato que queremos.
El código por fuerza bruta es bastante sencillo:
for(int i=0; i<Arreglo.length; i++)
if(Arreglo[i] == elemento)
System.out.println("\nElemento encontrado en la posicion: " + i);
Solo se recorre todo el arreglo y verificamos si la posición i es igual al dato que
queremos buscar, el código anterior se puede mejorar simplemente agregándole una bandera,
pero aun así no es lo suficientemente bueno.
El algoritmo de búsqueda binaria es el siguiente:
1. Se declaran los índices superior e inferior. El inferior en 0 y el superior con el tamaño
del arreglo menos 1.
2. Se calcula el centro del arreglo con la siguiente formula: centro = (superior +
inferior) / 2
3. Verificamos si el arreglo en la posición centro es igual al dato que buscamos. Si es
igual significa que encontramos el dato y retornamos centro.
4. Si son diferentes verificamos si el arreglo en la posición centro es mayor al dato
que queremos buscar. Si es mayor actualizamos superior: superior = centro - 1, si no
actualizamos inferior: inferior = centro + 1.

5. Volvemos al paso 2.
Si cuando ya no se cumpla la condición del ciclo y no se encontró el dato retornamos -1
indicando que el dato no se encuentra en el arreglo.

Búsqueda Binaria
El algoritmo de búsqueda binaria es un algoritmo muy eficiente que se aplica solo a listas
ordenadas. Funciona dividiendo repetidamente la lista en dos mitades y comparando el
elemento objetivo con el elemento del medio, esto reduce significativamente la cantidad de
comparaciones necesarias.
A continuación veremos un pequeño ejemplo de búsqueda binaria con Python.

89
90
91
 def busqueda_lineal(lista,valor):
steps=0
for i,item in enumerate(lista):
steps+=1
if item==valor:
return "Valor encontrado en {} pasos en la posición {}.".format(steps,i)
return "Elemento no encontrado."

lista= [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

busqueda=busqueda_lineal(lista,20)
print(busqueda)

Búsqueda Binaria en C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BusquedaBinaria
{
class Busqueda
{
private int[] vector;
public void Cargar()
{
Console.WriteLine("Busqueda Binaria");
Console.WriteLine("Ingrese 10 Elementos");
string linea;
vector = new int[10];
for (int f = 0; f< vector.Length; f++)
{
Console.Write("Ingrese elemento " + (f + 1) + ": ");
linea = Console.ReadLine();
vector[f] = int.Parse(linea);
92
 }
}
public void busqueda(int num)
{
int l = 0, h = 9;
int m = 0;
bool found = false;
while (l <= h && found == false)
{
m = (l + h) / 2;
if (vector[m] == num)
found = true;
if (vector[m] > num)
h = m - 1;
else
l = m + 1;
}
if (found == false)
{ Console.Write("\nEl elemento {0} no esta en el arreglo", num); }
else
{ Console.Write("\nEl elemento {0} esta en la posicion: {1}", num, m + 1); }
}
public void Imprimir()
{
for (int f = 0; f< vector.Length; f++)
{
Console.Write(vector[f] + " ");
}
}
static void Main(string[] args)
{
Busqueda pv = new Busqueda();
pv.Cargar();
pv.Imprimir();
Console.Write("\n\nElemento a buscar: ");
int num = int.Parse(Console.ReadLine());
pv.busqueda(num);
Console.ReadKey();

}
}
}

Al ejecutar el código muestra el siguiente resultado

93
def binary_search(lista, objetivo, inicio, fin ):
if inicio > fin:
return -1

centro = (inicio + fin) // 2

if lista[centro] == objetivo:
return centro
elif lista[centro] < objetivo:
return binary_search(lista, objetivo, centro + 1, fin)
else:
return binary_search(lista, objetivo, inicio, centro - 1)

# Ejemplo de uso
lista = [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 15, 20, 27, 34, 39, 50]
numero_objetivo = 27
inicio_busqueda = 0
fin_busqueda = len(lista) - 1

resultado = binary_search(lista, numero_objetivo, inicio_busqueda, fin_busqueda)

if resultado != -1:
print(f"El número {numero_objetivo} se encuentra en la posición {resultado}.")
else:
print(f"El númeor {numero_objetivo} NO se encuentra en la lista.")

En este ejemplo, hacemos uso de un algoritmo de búsqueda binario para encontrar el número 27 en una
lista de elementos ordenados, para poder encontrar el elemento que buscamos podemos hacer uso de una
función recursiva, en esta función el caso base sería si el número de la lista en la posición centro es igual
al número que buscamos, de ser así retornamos el valor de la variable centro este sería el índice del número,
de lo contrario, dividimos la lista en dos mitades y hacemos el llamado recursivo hasta encontrar el número
que buscamos pero si el número no se encuentra en la lista retornamos -1.

94
 Ventajas y Desventajas del Algoritmo de Búsqueda Binaria

Ventajas:

 Eficiencia de listas ordenadas: La principal ventaja de la búsqueda binaria es su eficiencia en

listas ordenadas. Su tiempo de ejecución es de O(log n), lo que significa que disminuye
rápidamente a medida que el tamaño de la lista aumenta.
 Menos comparaciones: Comparado con la búsqueda lineal, la búsqueda binaria realiza menos
comparaciones en promedio, lo que lo hace más rápido para encontrar el objetivo.

Desventajas:

 Requiere una lista ordenada: La búsqueda binaria sólo es aplicable a listas ordenadas, Si la lista
no está ordenada, se debe realizar una operación adicional para ordenarla antes de usar la
búsqueda binaria.
 Mayor complejidad de implementación: Comparado con la búsqueda lineal, la búsqueda binaria
es más compleja de implementar debido a su naturaleza recursiva.

Búsqueda Secuencial en C#

En informática, la búsqueda secuencial en C# lineal o la búsqueda secuencial es un

método para encontrar un valor objetivo dentro de una lista. Ésta comprueba
secuencialmente cada elemento de la lista para el valor objetivo hasta que es
encontrado o hasta que todos los elementos hayan sido comparados.

using System;
using System.Windows.Forms;
using Microsoft.VisualBasic;
/*
Autor: Programador novato
Fecha: 01/01/2021
Este programa hace que los novatos aprenden a hacer
un codigo bonito y ya
*/
namespace HolaMundo
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Humano ingresa el numero a buscar de la
lista");
int numeroBuscar=int.Parse(Console.ReadLine());
int[] listaNumeros = new int[7];
for (int i = 0; i < 7; i++)
{
Console.WriteLine("Humano ingresa el elemento "+(i+1)+" de la
lista");
int numero = int.Parse(Console.ReadLine());
listaNumeros[i] = numero;
}
95
 int pos = 0;
bool bandera = false;
while (pos < 7 && bandera == false) {
if (numeroBuscar == listaNumeros[pos]) {
bandera = true;
break;
}
pos++;
}
if (bandera == true)
{
Console.WriteLine("Felicidades humano se encontro el numero "
+ numeroBuscar + " en la posicion " + (pos+1));
}
else {
Console.WriteLine("Lo siento humano no se encontro el numero
"+numeroBuscar);
}
Console.Read();
}
}
}

La búsqueda secuencial

Cuando los ítems de datos se almacenan en una colección, por ejemplo en una lista, decimos que tienen una
relación lineal o secuencial. Cada ítem de datos se almacena en una posición relativa a los demás. En las
listas de Python, estas posiciones relativas son los valores de los índices de los ítems individuales. Dado
que estos valores de los índices están ordenados, es posible para nosotros visitarlos en secuencia. Este
proceso da lugar a nuestra primera técnica de búsqueda, la búsqueda secuencial.

La Figura 1 muestra cómo funciona esta búsqueda. Comenzando en el primer ítem de la lista, simplemente
nos trasladamos de un ítem a otro, siguiendo el orden secuencial subyacente hasta que encontremos lo que
buscamos o nos quedemos sin ítems. Si nos quedamos sin ítems, hemos descubierto que el ítem que
estábamos buscando no estaba presente.

La implementación en Python para este algoritmo se muestra en el CodeLens 1. La función necesita la lista
y el ítem que estamos buscando y devuelve un valor booleano que indica si el ítem está o no presente. La
variable booleana encontrado se inicializa en False y se le asigna el valor True si descubrimos el ítem en
la lista.
96
def busquedaSecuencial(unaLista, item):

pos = 0

encontrado = False

while pos < len(unaLista) and not encontrado:

if unaLista[pos] == item:

encontrado = True

else:

pos = pos+1

return encontrado

listaPrueba = [1, 2, 32, 8, 17, 19, 42, 13, 0]

print(busquedaSecuencial(listaPrueba, 3))

print(busquedaSecuencial(listaPrueba, 13))

97
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 18/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada
6. Entregables a definir por el profesor
7. Bibliografía
 LAAKMANN MCDOWELL, Gayle. Cracking the Coding Interview: 189
Programming Questions and Solutions. Palo Alto, CA., CareerCup, 2016.
 BELL, Douglas y PARR, Mike. C# para estudiantes. México, Pearson, 2010
 CEBALLOS SIERRA, Francisco Javier. Microsoft C#. Curso de
programación. México, Alfaomega, 2007
 DEITEL, Harvey y Deitel, PAUL. C# Cómo programar. España, Pearson,
2007
 LÓPEZ ROMÁN, Leobardo. Metodología de la programación orientada a
objetos. México, Alfaomega, 2007

98
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 19/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Práctica #4
Arboles
1. Seguridad en la ejecución

Peligro o Fuente de energía Riesgo asociado

1 Tensión alterna Electrocución

2. Objetivos de aprendizaje

OBJETIVO GENERAL: Entender e implementar Arboles en la especificación,

representación, operación, implementación y aplicaciones de los arboles.

OBJETIVOS ESPECÍFICOS:
 Comprender qué es un árbol de datos.
 Entender la aplicación de los principios de usabilidad y la experiencia del
usuario desde el punto de vista de programación.

4.- Expresiones
4.1.- Definición de árbol.
4.2.- Especificación y representación de árboles
4.3.- Operaciones en los árboles
4.4.- Implementación de árboles
4.5.- Aplicaciones de los árboles

99
 3. Introducción

Grafos y árboles en Python:

Recomendaciones
Antes de empezar a estudiar la teoría de grafos con Python, se recomienda contar con algunos conocimientos previos
antes de leer este artículo, por lo cual, dejo la invitación a revisar los siguientes enlaces de apoyo opcionales:

Prerrequisitos y consideraciones
Como prerrequisito se debe tener instalado Python 3.5+ en nuestro ordenador local. Si no tienes instalado Python,
consultar el siguiente enlace para la descarga.

También se necesita tener conceptos básicos de programación con Python o tener nociones de como se utiliza como
primera instancia.

La teoría de grafos es una rama matemática que se centra en examinar las relaciones entre objetos a través de
estructuras conocidas como “grafos”. Estos consisten en un conjunto de nodos (también llamados vértices) y un
conjunto de conexiones entre ellos, denominadas aristas.

Esta disciplina matemática encuentra aplicaciones extensas en diversas áreas, ya que los grafos se utilizan para
modelar y analizar una amplia gama de situaciones. La teoría de grafos proporciona conceptos y técnicas que
posibilitan la representación y resolución de problemas donde es crucial comprender las interconexiones y las
relaciones entre elementos. En esencia, permite abordar cuestiones que involucran la estructura y la interacción de
elementos en diferentes contextos.

Teoría de grafos en la informática

La teoría de grafos es una herramienta fundamental en la informática y tiene una amplia gama de aplicaciones en esta
área. Algunas de las principales formas en que se utiliza la teoría de grafos en la informática incluyen:

100
 1. Redes y comunicaciones: La teoría de grafos se utiliza para modelar y analizar redes de comunicación, como
redes de computadoras, internet, redes sociales y sistemas de telecomunicaciones.
2. Algoritmos de búsqueda y ruta: Los algoritmos de búsqueda y ruta, como el algoritmo de Dijkstra y el
algoritmo de Bellman-Ford, se basan en conceptos de teoría de grafos para encontrar caminos más cortos o
rutas óptimas en redes.
3. Bases de datos: La representación de relaciones entre datos se puede hacer utilizando estructuras de grafos
en bases de datos NoSQL como bases de datos de grafos.
4. Inteligencia artificial: Los grafos se utilizan para modelar relaciones en conjuntos de datos, como en redes
neuronales, procesamiento del lenguaje natural y recomendación de sistemas.
5. Geolocalización y mapas: La teoría de grafos se aplica en la optimización de rutas, análisis de redes de
transporte y en la representación de relaciones espaciales en sistemas de mapas y geolocalización.

Conceptos clave de la teoría de grafos

1. Nodos (Vértices): Los nodos son los elementos individuales del grafo y pueden representar cualquier
entidad, como ciudades en un mapa, usuarios en una red social o puntos en un conjunto numérico.
2. Aristas: Las aristas son las conexiones entre los nodos y pueden ser no direccionales (bidireccionales) o
direccionales (unidireccionales).
3. Grafos: Un grafo es simplemente una colección de nodos y aristas que están interconectados de alguna
manera.
4. Grado de un nodo: El grado de un nodo es el número de aristas que están conectadas a él. En grafos
dirigidos, se diferencia entre el grado de entrada (número de aristas que apuntan al nodo) y el grado de
salida (número de aristas que salen del nodo).
5. Camino y camino más corto: Un camino es una secuencia de nodos y aristas que conecta dos nodos en
el grafo. El camino más corto es aquel que tiene la menor cantidad de aristas entre esos dos nodos.
6. Árboles: Los árboles son grafos conectados que no tienen ciclos, es decir, no forman circuitos cerrados.
Son útiles en estructuras jerárquicas y tienen aplicaciones en algoritmos de búsqueda y optimización.

Grafos

Reforzando lo anterior, en un grafo, los nodos son elementos individuales que representan puntos discretos, mientras
que las aristas son conexiones que vinculan pares de nodos. A su vez, podemos encontrar diferentes tipos de Grafos
dependiendo de la dirección de la arista:

 Grafos dirigidos: En un grafo dirigido, las aristas tienen una dirección específica, lo que implica que las
conexiones entre los nodos tienen un origen y un destino claramente definidos.

101
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 20/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Grafos no dirigidos:
En un grafo no dirigido, las aristas no tienen dirección, representando relaciones simétricas entre los
nodos, donde la conexión es bidireccional.

Grafos cíclicos:
Un grafo es cíclico si contiene un ciclo, es decir, un camino cerrado donde el último nodo está conectado
al primer nodo, creando una secuencia de aristas que permite regresar al punto de partida.

Grafos bipartitos:
Estos son grafos cuyos nodos se pueden dividir en dos conjuntos disjuntos, y todas las aristas conectan
nodos de conjuntos diferentes. Esta estructura bipartita tiene aplicaciones en modelar relaciones entre
conjuntos distintos en diversos contextos.

102
 Trabajando con Grafos en Python
Para trabajar grafos Python, lo podemos hacer apoyándonos con la programación orientada a objetos.
Para representar un grafo básico cíclico lo podemos hacer de esta manera:

class Node:
def __init__(self, value):
self.value = value
self.connections = []

class Edge:
def __init__(self, origin, destination):
self.origin = origin
self.destination = destination

node_a = Node("A")
node_b = Node("B")
node_c = Node("C")
edge_ab = Edge(node_a, node_b)
edge_bc = Edge(node_b, node_c)
edge_ca = Edge(node_c, node_a)
node_a.connections.append(edge_ab)
node_b.connections.append(edge_bc)
node_c.connections.append(edge_ca)

Explicación del código:

1. Clase Node (Nodo): La clase Node representa un nodo en el grafo. Cada nodo tiene un valor (value) que
puede ser cualquier tipo de dato (por ejemplo, una cadena de texto). Cada nodo también tiene una lista
llamada connections, que se utiliza para almacenar los bordes que están conectados a este nodo.
2. Clase Edge (Artista en español): La clase Edge representa una artista en el grafo. Cada arista tiene dos
partes: un nodo de origen (origin) y un nodo de destino (destination), lo que significa que el la arista va desde
el nodo de origen hasta el nodo de destino.
3. Creación de nodos: Se crean tres nodos llamados node_a, node_b y node_c, cada uno con un valor único.
4. Creación de aristas: Se crean tres aristas llamadas edge_ab, edge_bc y edge_ca. Cada arista se crea
conectando dos nodos. Por ejemplo, edge_ab conecta el nodo node_a como origen y el nodo node_b como
destino.
5. Conexiones entre nodos y aristas: Cada nodo tiene una lista llamada connections donde se almacenan
las aristas que están conectados a ese nodo. Las aristas recién creadas se agregan a las listas de
conexiones de los nodos correspondientes. Por ejemplo, la arista edge_ab se agrega a la lista de conexiones
del nodo node_a.

103
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 21/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Árboles
Un árbol es una categoría especial de grafo que tiene dos propiedades importantes: es acíclico y conexo.
La característica acíclica significa que no contiene ciclos ni bucles, es decir, no hay caminos cerrados. La
propiedad conexa indica que hay un camino entre cualquier par de nodos en el árbol.
La estructura de árbol se asemeja a una jerarquía, similar a la ramificación de un árbol real. En un árbol,
hay un nodo especial llamado “raíz” desde el cual se extienden ramas (aristas) hacia otros nodos llamados
“hojas”. La conexión entre los nodos forma una estructura de ramificación que refleja una relación
jerárquica. Los árboles son ampliamente utilizados en informática y estructuras de datos para organizar
información de manera eficiente, como en árboles de búsqueda binaria o en la representación de
jerarquías en sistemas de archivos.
A su vez, los árboles pueden ser de los siguientes tipos (básicos):
 Árbol Binario: Un árbol binario es una estructura en la que cada nodo puede tener hasta dos
descendientes: un hijo a la izquierda y otro a la derecha. En un árbol binario, cada nodo se ramifica
en, como máximo, dos direcciones. El hijo izquierdo y el hijo derecho representan subárboles
independientes que pueden a su vez tener sus propios hijos.

Árbol de búsqueda binaria: Un árbol de búsqueda binaria es un árbol binario en el que los valores en
los nodos están ordenados de tal manera que los valores menores se encuentran en el subárbol
izquierdo y los valores mayores en el subárbol derecho. En otras palabras, todos los valores en el
subárbol izquierdo son menores que el valor del nodo y Todos los valores en el subárbol derecho son
mayores que el valor del nodo.

104
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 22/25
Programación Sección 8.3
Orientada a Objetos ISO
Fecha de
16 de enero de
emisión
2024
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no
controlada

Trabajando con Árboles en Python

Para trabajar con árboles en Python, también lo podemos hacer mediante la programación orientada a objetos.
Para representar un árbol binario lo podemos hacer de esta manera:

class Node:
def __init__(self, value):
self.value = value
self.left = None
self.right = None

class BinaryTree:
def __init__(self):
self.root = None

def insert(self, value):

self.root = self._insert_recursive(self.root, value)

def _insert_recursive(self, node, value):

if node is None:
return Node(value)

if value < node.value:

node.left = self._insert_recursive(node.left, value)
else:
node.right = self._insert_recursive(node.right, value)

return node

def search(self, value):

return self._search_recursive(self.root, value)

def _search_recursive(self, node, value):

105
 if node is None:
return False

if node.value == value:
return True

if value < node.value:

return self._search_recursive(node.left, value)
else:
return self._search_recursive(node.right, value)

def inorder_traversal(self, node):

if node is not None:
self.inorder_traversal(node.left)
print(node.value, end=" ")
self.inorder_traversal(node.right)

tree = BinaryTree()
tree.insert(5)
tree.insert(3)
tree.insert(7)
tree.insert(2)
tree.insert(4)
tree.insert(6)
tree.insert(8)
print(tree.search(4)) # True
print(tree.search(9)) # False
print("Inorder traversal:")
tree.inorder_traversal(tree.root)

Explicación del código:

1. Definición de Clase Node (Nodo): Esta clase representa un nodo individual en el árbol binario. Cada
nodo tiene un valor (value), y puede tener un hijo izquierdo (left) y un hijo derecho (right). Los nodos son
los bloques de construcción del árbol.
2. Definición de Clase BinaryTree (Árbol Binario): Esta clase representa el árbol binario en sí. Tiene un
atributo root (raíz) que apunta al nodo raíz del árbol. Tiene métodos para insertar valores (insert), buscar
valores (search) y realizar un recorrido inorder (inorder_traversal).
3. Método insert (Insertar): Toma un valor como entrada y utiliza el método privado _insert_recursive para
insertar ese valor en el árbol. Si el árbol está vacío, crea un nuevo nodo con el valor proporcionado y lo
convierte en la raíz. Si no está vacío, utiliza recursión para determinar si el valor debe ser insertado en el
subárbol izquierdo o derecho.
4. Método _insert_recursive (Insertar Recursivo): Este método es recursivo y se encarga de insertar un
valor en el árbol. Si el nodo es None, crea un nuevo nodo con el valor y lo devuelve. Si el valor es menor
que el valor del nodo actual, llama al método recursivamente para el subárbol izquierdo. Si el valor es
mayor o igual, llama al método recursivamente para el subárbol derecho.
5. Método search (Buscar): Toma un valor como entrada y utiliza el método privado _search_recursive para
buscar ese valor en el árbol. Comienza la búsqueda desde la raíz y realiza una búsqueda recursiva
descendente en el subárbol izquierdo o derecho según sea necesario.
6. Método _search_recursive (Buscar Recursivo): Este método es recursivo y busca un valor en el árbol.
Si el nodo es None, significa que no se encontró el valor y retorna False. Si el valor coincide con el valor
del nodo actual, retorna True. Si el valor es menor que el valor del nodo actual, llama al método
recursivamente para el subárbol izquierdo. Si el valor es mayor, llama al método recursivamente para el
subárbol derecho.
7. Método inorder_traversal (Recorrido Inorder): Realiza un recorrido inorder en el árbol (izquierda, nodo,

106
 derecha). Imprime los valores de los nodos en orden ascendente.
8. Creación del Árbol y operaciones: Se crea una instancia de la clase BinaryTree llamada tree. Se
insertan varios valores en el árbol utilizando el método insert. Se busca valores en el árbol utilizando el
método search. Se realiza un recorrido inorder en el árbol utilizando el método inorder_traversal.

4. Material y equipo

Computadora

5. Desarrollo

Actividad 1. Implementación de una solución usando arboles.

Ir a la URL: https://sites.google.com/site/programacioniiuno/temario/unidad-5---
grafos/rboles y realizar las siguientes actividades:

1.-Implementa en PYTHON el árbol genealógico de la familia SIMPSON.

2.- Explica el siguiente diagrama esquemático de solución del mismo:

3.- Muestra a tu profesor la salida de dicho programa en PYTHON.

107
 Código: UNITEC-INGMP01
Versión: 01
Manual de prácticas de Página 25/25
Programación Orientada Sección ISO 8.3
a Objetos Fecha de
16 de enero de 2024
emisión
Área/Departamento:
Facultad de Ingeniería
Laboratorio de Cómputo de Ingeniería en
Sistemas Computacionales
La impresión de este documento es una copia no controlada

Actividad 2. Ejercicios a resolver en PYTHON:

La siguiente actividad debes entregar todos los ejercicios de programación resueltos

e implementados en PYTHON:

Ejercicio 1

Escribir un programa que muestre por pantalla la cadena ¡Hola Mundo!.

Ejercicio 2

Escribir un programa que almacene la cadena ¡Hola Mundo! en una variable y luego
muestre por pantalla el contenido de la variable.

Ejercicio 3

Escribir un programa que pregunte el nombre del usuario en la consola y después

de que el usuario lo introduzca muestre por pantalla la cadena ¡Hola <nombre>!,
donde <nombre> es el nombre que el usuario haya introducido.

Ejercicio 4

Escribir un programa que muestre por pantalla el resultado de la siguiente operación

aritmética

Ejercicio 5

Escribir un programa que pregunte al usuario por el número de horas trabajadas y

el coste por hora. Después debe mostrar por pantalla la paga que le corresponde.

Ejercicio 6

Escribir un programa que lea un entero positivo,

, introducido por el usuario y después muestre en pantalla la suma de todos los
enteros desde 1 hasta . La suma de los primeros enteros positivos puede ser
calculada de la siguiente forma:

108
Ejercicio 7

Escribir un programa que pida al usuario su peso (en kg) y estatura (en metros),
calcule el índice de masa corporal y lo almacene en una variable, y muestre por
pantalla la frase Tu índice de masa corporal es <imc> donde <imc> es el índice de
masa corporal calculado redondeado con dos decimales.

Ejercicio 8

Escribir un programa que pida al usuario dos números enteros y muestre por
pantalla la <n> entre <m> da un cociente <c> y un resto <r> donde <n> y <m> son
los números introducidos por el usuario, y <c> y <r> son el cociente y el resto de la
división entera respectivamente.

Ejercicio 9

Escribir un programa que pregunte al usuario una cantidad a invertir, el interés anual
y el número de años, y muestre por pantalla el capital obtenido en la inversión.

Ejercicio 10

Una juguetería tiene mucho éxito en dos de sus productos: payasos y muñecas.
Suele hacer venta por correo y la empresa de logística les cobra por peso de cada
paquete así que deben calcular el peso de los payasos y muñecas que saldrán en
cada paquete a demanda. Cada payaso pesa 112 g y cada muñeca 75 g. Escribir
un programa que lea el número de payasos y muñecas vendidos en el último pedido
y calcule el peso total del paquete que será enviado.

Ejercicio 11

Imagina que acabas de abrir una nueva cuenta de ahorros que te ofrece el 4% de
interés al año. Estos ahorros debido a intereses, que no se cobran hasta finales de
año, se te añaden al balance final de tu cuenta de ahorros. Escribir un programa
que comience leyendo la cantidad de dinero depositada en la cuenta de ahorros,
introducida por el usuario. Después el programa debe calcular y mostrar por pantalla
la cantidad de ahorros tras el primer, segundo y tercer años. Redondear cada
cantidad a dos decimales.

Ejercicio 12

Una panadería vende barras de pan a 3.49 cada una. El pan que no es el día tiene
un descuento del 60%. Escribir un programa que comience leyendo el número de
barras vendidas que no son del día. Después el programa debe mostrar el precio
habitual de una barra de pan, el descuento que se le hace por no ser fresca y el
coste final total.

109
Ejercicio 13

Escribir un programa que pregunte el nombre del usuario en la consola y un número

entero e imprima por pantalla en líneas distintas el nombre del usuario tantas veces
como el número introducido.

Ejercicio 14

Escribir un programa que pregunte el nombre completo del usuario en la consola y

después muestre por pantalla el nombre completo del usuario tres veces, una con
todas las letras minúsculas, otra con todas las letras mayúsculas y otra solo con la
primera letra del nombre y de los apellidos en mayúscula. El usuario puede introducir
su nombre combinando mayúsculas y minúsculas como quiera.

Ejercicio 15

Escribir un programa que pregunte el nombre del usuario en la consola y después

de que el usuario lo introduzca muestre por pantalla <NOMBRE> tiene <n> letras,
donde <NOMBRE> es el nombre de usuario en mayúsculas y <n> es el número de
letras que tienen el nombre.

Ejercicio 16

Los teléfonos de una empresa tienen el siguiente formato prefijo-número-extension

donde el prefijo es el código del país +34, y la extensión tiene dos dígitos (por
ejemplo +34-913724710-56). Escribir un programa que pregunte por un número de
teléfono con este formato y muestre por pantalla el número de teléfono sin el prefijo
y la extensión.

Ejercicio 17

Escribir un programa que pida al usuario que introduzca una frase en la consola y
muestre por pantalla la frase invertida.

Ejercicio 18

Escribir un programa que pida al usuario que introduzca una frase en la consola y
una vocal, y después muestre por pantalla la misma frase pero con la vocal
introducida en mayúscula.

Ejercicio 19

Escribir un programa que pregunte el correo electrónico del usuario en la consola y

muestre por pantalla otro correo electrónico con el mismo nombre (la parte delante
de la arroba @) pero con dominio ceu.es.

Ejercicio 20

Escribir un programa que pregunte por consola el precio de un producto en euros

con dos decimales y muestre por pantalla el número de euros y el número de
110
céntimos del precio introducido.

Ejercicio 21

Escribir un programa que pregunte al usuario la fecha de su nacimiento en formato

dd/mm/aaaa y muestra por pantalla, el día, el mes y el año. Adaptar el programa
anterior para que también funcione cuando el día o el mes se introduzcan con un
solo carácter.

Ejercicio 22

Escribir un programa que pregunte por consola por los productos de una cesta de
la compra, separados por comas, y muestre por pantalla cada uno de los productos
en una línea distinta.

Ejercicio 23

Escribir un programa que pregunte el nombre el un producto, su precio y un número

de unidades y muestre por pantalla una cadena con el nombre del producto seguido
de su precio unitario con 6 dígitos enteros y 2 decimales, el número de unidades
con tres dígitos y el coste total con 8 dígitos enteros y 2 decimales.

Ejercicio 24

Escribir un programa que pregunte al usuario su edad y muestre por pantalla si es

mayor de edad o no.

Ejercicio 25

Escribir un programa que almacene la cadena de caracteres contraseña en una

variable, pregunte al usuario por la contraseña e imprima por pantalla si la
contraseña introducida por el usuario coincide con la guardada en la variable sin
tener en cuenta mayúsculas y minúsculas.

Ejercicio 26

Escribir un programa que pida al usuario dos números y muestre por pantalla su
división. Si el divisor es cero el programa debe mostrar un error.

Ejercicio 27

Escribir un programa que pida al usuario un número entero y muestre por pantalla
si es par o impar.

Ejercicio 28

Para tributar un determinado impuesto se debe ser mayor de 16 años y tener unos
ingresos iguales o superiores a 1000 € mensuales. Escribir un programa que
pregunte al usuario su edad y sus ingresos mensuales y muestre por pantalla si el
usuario tiene que tributar o no.
111
Ejercicio 29

Los alumnos de un curso se han dividido en dos grupos A y B de acuerdo al sexo y

el nombre. El grupo A esta formado por las mujeres con un nombre anterior a la M
y los hombres con un nombre posterior a la N y el grupo B por el resto. Escribir un
programa que pregunte al usuario su nombre y sexo, y muestre por pantalla el grupo
que le corresponde.

Ejercicio 30

Los tramos impositivos para la declaración de la renta en un determinado país son

los siguientes:

Escribir un programa que pregunte al usuario su renta anual y muestre por pantalla
el tipo impositivo que le corresponde.

Ejercicio 31

En una determinada empresa, sus empleados son evaluados al final de cada año.
Los puntos que pueden obtener en la evaluación comienzan en 0.0 y pueden ir
aumentando, traduciéndose en mejores beneficios. Los puntos que pueden
conseguir los empleados pueden ser 0.0, 0.4, 0.6 o más, pero no valores
intermedios entre las cifras mencionadas. A continuación se muestra una tabla con
los niveles correspondientes a cada puntuación. La cantidad de dinero conseguida
en cada nivel es de 2.400€ multiplicada por la puntuación del nivel.

Escribir un programa que lea la puntuación del usuario e indique su nivel de

rendimiento, así como la cantidad de dinero que recibirá el usuario.

Ejercicio 32

Escribir un programa para una empresa que tiene salas de juegos para todas las
edades y quiere calcular de forma automática el precio que debe cobrar a sus
clientes por entrar. El programa debe preguntar al usuario la edad del cliente y
mostrar el precio de la entrada. Si el cliente es menor de 4 años puede entrar gratis,
si tiene entre 4 y 18 años debe pagar 5€ y si es mayor de 18 años, 10€.

112
Ejercicio 33

La pizzería Bella Napoli ofrece pizzas vegetarianas y no vegetarianas a sus clientes.

Los ingredientes para cada tipo de pizza aparecen a continuación.

Ingredientes vegetarianos: Pimiento y tofu.

Ingredientes no vegetarianos: Peperoni, Jamón y Salmón.

Escribir un programa que pregunte al usuario si quiere una pizza vegetariana o no,
y en función de su respuesta le muestre un menú con los ingredientes disponibles
para que elija. Solo se puede eligir un ingrediente además de la mozzarella y el
tomate que están en todas la pizzas. Al final se debe mostrar por pantalla si la pizza
elegida es vegetariana o no y todos los ingredientes que lleva.

Ejercicio 34

Escribir un programa que pida al usuario una palabra y la muestre por pantalla 10
veces.

Ejercicio 35

Escribir un programa que pregunte al usuario su edad y muestre por pantalla todos
los años que ha cumplido (desde 1 hasta su edad).

Ejercicio 36

Escribir un programa que pida al usuario un número entero positivo y muestre por
pantalla todos los números impares desde 1 hasta ese número separados por
comas.

Ejercicio 37

Escribir un programa que pida al usuario un número entero positivo y muestre por
pantalla la cuenta atrás desde ese número hasta cero separados por comas.

Ejercicio 38

Escribir un programa que pregunte al usuario una cantidad a invertir, el interés anual
y el número de años, y muestre por pantalla el capital obtenido en la inversión cada
año que dura la inversión.

Ejercicio 39

Escribir un programa que pida al usuario un número entero y muestre por pantalla
un triángulo rectángulo como el de más abajo, de altura el número introducido.

*
**
***
****
113
*****

Ejercicio 40

Escribir un programa que muestre por pantalla la tabla de multiplicar del 1 al 10.

Ejercicio 41

Escribir un programa que pida al usuario un número entero y muestre por pantalla
un triángulo rectángulo como el de más abajo.

1
31
531
7531
97531

Ejercicio 42

Escribir un programa que almacene la cadena de caracteres contraseña en una

variable, pregunte al usuario por la contraseña hasta que introduzca la contraseña
correcta.

Ejercicio 43

Escribir un programa que pida al usuario un número entero y muestre por pantalla
si es un número primo o no.

Ejercicio 44

Escribir un programa que pida al usuario una palabra y luego muestre por pantalla
una a una las letras de la palabra introducida empezando por la última.

Ejercicio 45

Escribir un programa en el que se pregunte al usuario por una frase y una letra, y
muestre por pantalla el número de veces que aparece la letra en la frase.

Ejercicio 46

Escribir un programa que muestre el eco de todo lo que el usuario introduzca hasta
que el usuario escriba “salir” que terminará.

Ejercicio 47

Escribir un programa que almacene las asignaturas de un curso (por ejemplo

Matemáticas, Física, Química, Historia y Lengua) en una lista y la muestre por
pantalla.

114
Ejercicio 48

Escribir un programa que almacene las asignaturas de un curso (por ejemplo

Matemáticas, Física, Química, Historia y Lengua) en una lista y la muestre por
pantalla el mensaje Yo estudio <asignatura>, donde <asignatura> es cada una de
las asignaturas de la lista.

Ejercicio 49

Escribir un programa que almacene las asignaturas de un curso (por ejemplo

Matemáticas, Física, Química, Historia y Lengua) en una lista, pregunte al usuario
la nota que ha sacado en cada asignatura, y después las muestre por pantalla con
el mensaje En <asignatura> has sacado <nota> donde <asignatura> es cada una
des las asignaturas de la lista y <nota> cada una de las correspondientes notas
introducidas por el usuario.

Ejercicio 50

Escribir un programa que pregunte al usuario los números ganadores de la lotería

primitiva, los almacene en una lista y los muestre por pantalla ordenados de menor
a mayor.

6. Entregables a definir por el profesor

7. Bibliografía
Bibliografía Programación Python
• Algar Díaz, M. J. & Fernández de Sevilla Vellón, M. (2019). Introducción práctica a la
programación con Python. Universidad de Alcalá.
https://elibro.net/es/lc/unapec/titulos/124259
• Arboledas Brihuega, D. (2017). Criptografía sin secretos con Python. RA-MA.
https://elibro.net/es/lc/unapec/titulos/106497
• Arboledas Brihuega, D. (2017). Criptografía sin secretos con Python. RA-MA
Editorial.
https://search.ebscohost.com/login.aspx?direct=true&db=e000xww&AN=2498257&lang
=es&site=ehost-live
• Arévalo Ovalle, D. (2021). Métodos numéricos con Python. 1. Politécnico
Grancolombiano. https://elibro.net/es/lc/unapec/titulos/218585
• Arnáez Braschi, E. (2015). Enfoque práctico de la teoría de robots: Con
aplicaciones en Matlab. Universidad Peruana de Ciencias Aplicadas.
https://search.ebscohost.com/login.aspx?direct=true&db=e000xww&AN=1093458&lang
=es&site=ehost-live
• Arroyo Guardeño, D. Gayoso Martínez, V. & Hernández Encinas, L.
(2020). Ciberseguridad. CSIC Consejo Superior de Investigaciones Científicas.
https://elibro.net/es/lc/unapec/titulos/172144
• Astudillo B. K. (2019). Hacking ético (3a ed.). Ediciones de la U.
https://elibro.net/es/lc/unapec/titulos/127123
• Baca Urbina, G. (2016). Introducción a la seguridad informática. Grupo Editorial
Patria. https://elibro.net/es/lc/unapec/titulos/40458
• Barría Huidobro, C. & Rosales Guerrero, S. (2021). Amenazados: seguridad e
inseguridad en la web. Editorial ebooks Patagonia - Ediciones UM.
https://elibro.net/es/lc/unapec/titulos/195488

115