UNIVERSIDAD PUBLICA DE EL ALTO

CARRERA INGENIERÍA DE SISTEMAS

PROGRAMACIÓN II
Peralta Quiroga Brandon Joaquin
Apellidos y nombres: ……………………………………………………….
Fecha de Presentación :……./………/……… Paralelo………………………………………. Ap. Inicial

1.1. IDENTIFIQUE LAS PALABRAS DE POO EN LA SOPA DE LETRAS, LUEGO: CONCEPTUALICE Y

EJEMPLIFIQUE CADA UNA DE LAS PALABRAS EN POO.

EJERCICIO 1,1

1.2. CREAR LOS SIGUIENTES OBJETOS DEFINIENDO ATRIBUTOS Y MÉTODOS. -CELULAR-RELOJ-

FRUTA-TELEVISOR-BOLÍGRAFO-PUERTA
class Celular:
def __init__(self, marca, modelo, color):
self.marca = marca
self.modelo = modelo
self.color = color

def llamar(self, numero):

print(f"Llamando al número {numero} desde el celular {self.marca} {self.modelo}.")

class Reloj:
def __init__(self, marca, modelo, color):
self.marca = marca
self.modelo = modelo
self.color = color

def mostrar_hora(self):
# Supongamos que esta función muestra la hora actual del reloj
pass

class Fruta:
def __init__(self, nombre, color, sabor):
self.nombre = nombre
self.color = color
self.sabor = sabor

def describir(self):
print(f"La fruta {self.nombre} es de color {self.color} y tiene un sabor {self.sabor}.")

class Televisor:
def __init__(self, marca, modelo, pulgadas):
self.marca = marca
self.modelo = modelo
 self.pulgadas = pulgadas

def encender(self):
print("Encendiendo el televisor.")

def cambiar_canal(self, canal):

print(f"Cambiando al canal {canal}.")

class Boligrafo:
def __init__(self, marca, color, grosor):
self.marca = marca
self.color = color
self.grosor = grosor

def escribir(self, texto):

print(f"Escribiendo '{texto}' con el bolígrafo {self.marca} {self.color}.")

class Puerta:
def __init__(self, material, color, alto, ancho):
self.material = material
self.color = color
self.alto = alto
self.ancho = ancho

def abrir(self):
print("Abriendo la puerta.")

def cerrar(self):
print("Cerrando la puerta.")
# Crear un celular
mi_celular = Celular("Samsung", "Galaxy S21", "Negro")

# Crear un reloj
mi_reloj = Reloj("Casio", "G-Shock", "Negro")

# Crear una fruta

mi_fruta = Fruta("Manzana", "Rojo", "Dulce")

# Crear un televisor
mi_televisor = Televisor("Sony", "Bravia", 55)

# Crear un bolígrafo
mi_boligrafo = Boligrafo("Bic", "Azul", "Mediano")

# Crear una puerta

mi_puerta = Puerta("Madera", "Café", 200, 80)
mi_celular.llamar("123456789")
mi_fruta.describir()
mi_televisor.encender()
mi_boligrafo.escribir("Hola mundo")
mi_puerta.abrir()
1.3. ELABORAR UN DIAGRAMA DE LA HERENCIA DE LOS OBJETOS LISTADOS-VEHÍCULO-AVE-
FRUTA-CASA-MUNICIPIO

Vehículo

/ \

Casa Ave

Fruta

Municipio

1.4. DISEÑE LA ESTRUCTURA DE UNA CLASE EJEMPLIFICANDO EN LA PREGUNTA 1.2.

CELULAR

class Celular:
def __init__(self, marca, modelo, color):
self.marca = marca
self.modelo = modelo
self.color = color
self.encendido = False # Atributo para indicar si el celular está encendido o no

def encender(self):
if not self.encendido:
print("Encendiendo el celular.")
self.encendido = True
else:
print("El celular ya está encendido.")

def apagar(self):
if self.encendido:
print("Apagando el celular.")
self.encendido = False
else:
print("El celular ya está apagado.")

def llamar(self, numero):

if self.encendido:
print(f"Llamando al número {numero} desde el celular {self.marca} {self.modelo}.")
else:
print("No se puede llamar. El celular está apagado.")

# Ejemplo de uso
mi_celular = Celular("Samsung", "Galaxy S21", "Negro")
mi_celular.encender() # Enciende el celular
mi_celular.llamar("123456789") # Intenta llamar
mi_celular.apagar() # Apaga el celular

RELOJ

class Reloj:
def __init__(self, marca, modelo, color):
self.marca = marca
self.modelo = modelo
self.color = color
self.horas = 0
self.minutos = 0
self.segundos = 0

def establecer_hora(self, horas, minutos, segundos):

if 0 <= horas < 24 and 0 <= minutos < 60 and 0 <= segundos < 60:
self.horas = horas
self.minutos = minutos
self.segundos = segundos
else:
print("Error: La hora ingresada no es válida.")

def mostrar_hora(self):
print(f"{self.horas:02d}:{self.minutos:02d}:{self.segundos:02d}")

def avanzar_segundo(self):
self.segundos += 1
if self.segundos == 60:
self.segundos = 0
self.avanzar_minuto()

def avanzar_minuto(self):
self.minutos += 1
if self.minutos == 60:
self.minutos = 0
self.avanzar_hora()

def avanzar_hora(self):
self.horas += 1
if self.horas == 24:
self.horas = 0

# Ejemplo de uso
mi_reloj = Reloj("Casio", "Digital", "Negro")
mi_reloj.establecer_hora(12, 30, 0)
mi_reloj.mostrar_hora()
mi_reloj.avanzar_segundo()
mi_reloj.mostrar_hora()
FRUTA

class Fruta:
def __init__(self, nombre, color, sabor):
self.nombre = nombre
 self.color = color
self.sabor = sabor
self.estado = "Fresco" # Estado inicial de la fruta

def madurar(self):
if self.estado == "Fresco":
self.estado = "Maduro"
print(f"{self.nombre} está maduro ahora.")
elif self.estado == "Maduro":
print(f"{self.nombre} ya está maduro.")
else:
print(f"{self.nombre} está podrido, no puede madurar más.")

def podrirse(self):
if self.estado != "Podrido":
self.estado = "Podrido"

print(f"{self.nombre} se ha podrido.")
else:
print(f"{self.nombre} ya está podrido.")

def mostrar_informacion(self):
print(f"Nombre: {self.nombre}")
print(f"Color: {self.color}")
print(f"Sabor: {self.sabor}")
print(f"Estado: {self.estado}")

# Ejemplo de uso
mi_fruta = Fruta("Manzana", "Rojo", "Dulce")
mi_fruta.mostrar_informacion()
mi_fruta.madurar()
mi_fruta.mostrar_informacion()
mi_fruta.podrirse()
mi_fruta.mostrar_informacion()

1.4. CUÁLES SON LAS CARACTERÍSTICAS FUNDAMENTALES DE LA POO. MENCIONE Y DEFINA

RESPUESTA. -

La programación orientada en objetos o también llamado POO se basa en 4 características

principales: Abstracción, Encapsulamiento, Herencia, Polimorfosis.

Abstracción:

En POO, la abstracción implica identificar las características esenciales de un objeto del mundo
real y representarlas en un modelo de programación. Esto se logra mediante la creación de
clases, que son como plantillas para crear objetos. Las clases encapsulan datos (atributos) y
comportamientos (métodos) relevantes para el objeto que están modelando. Por ejemplo, una
clase "Coche" puede tener atributos como "marca", "modelo “y "color", y métodos como
"arrancar", "acelerar" y "frenar".
Encapsulamiento:

El encapsulamiento consiste en ocultar los detalles de implementación de un objeto y exponer

solo una interfaz que permita interactuar con él. En POO, esto se logra utilizando modificadores
de acceso para controlar el acceso a los atributos y métodos de una clase. El encapsulamiento
ayuda a proteger los datos de la clase de modificaciones no deseadas y permite una mayor
modularidad y reutilización del código.

Herencia:

La herencia es un mecanismo que permite que una clase herede atributos y métodos de otra
clase. En POO, una clase que hereda de otra se denomina "subclase" o "clase derivada", y la
clase de la que heredase denomina "superclase" o "clase base". La herencia permite la
reutilización de código al permitir que las subclases extiendan o modifiquen el
comportamiento de la superclase. Por ejemplo, puedes tener una clase "Animal" con atributos
y métodos comunes, y luego crear subclases como "Perro" y "Gato" que hereden esos
atributos y métodos.

Polimorfismo:

El polimorfismo es la capacidad de un objeto para tomar muchas formas diferentes. En POO,

esto se logra de diferentes maneras, como la sobrecarga de métodos y la sobreescritura de
métodos. La sobrecarga de métodos permite que una clase tenga múltiples métodos con el
mismo nombre, pero diferentes parámetros, lo que permite realizar diferentes acciones según
los argumentos proporcionados. La sobreescritura de métodos permite que una subclase
proporcione una implementación específica de un método que ya está definido en su
superclase, lo que permite que diferentes clases compartan un mismo nombre de método,
pero con comportamientos diferentes.

1.6. CONSTRUYA EL POLIMORFISMO DE: -FIGURA GEOMÉTRICA-GATO-PERSONA- VEHÍCULO-

RUEDA

class FiguraGeometrica:
def __init__(self, tipo):
self.tipo = tipo

def describir(self):
return f"Esta es una figura geométrica de tipo {self.tipo}."

class Gato:
def __init__(self, nombre):
self.nombre = nombre

def describir(self):
return f"Este es un gato llamado {self.nombre}."

class Persona:
 def __init__(self, nombre):
self.nombre = nombre

def describir(self):
return f"Esta es una persona llamada {self.nombre}."

class Vehiculo:
def __init__(self, marca, modelo):
self.marca = marca
self.modelo = modelo

def describir(self):
return f"Este es un vehículo de la marca {self.marca} y modelo {self.modelo}."

class Rueda:
def __init__(self, diametro):
self.diametro = diametro

def describir(self):
return f"Esta es una rueda con un diámetro de {self.diametro} pulgadas."

# Ejemplo de uso del polimorfismo

objetos = [FiguraGeometrica("cuadrado"), Gato("Garfield"), Persona("John"), Vehiculo("Toyota",
"Corolla"), Rueda(18)]

for objeto in objetos:

print(objeto.describir())

1.7. ¿CUÁL ES LA DIFERENCIA ENTRE LA ESTRUCTURA Y CLASE?

RESPUESTA. -

La estructura y la clase tienen diferencias significativas aun con conceptos relacionados

especialmente en la programación orientada en objetos.

CLASE.

-Una clase en la programación es como un modelen la programación para crear plantillas

define las propiedades y comportamientos (Atributos-Métodos) -
En POO las clases son fundamental para representar entidades del mundo real.
-Las clases permiten encapsular datos y funciones relacionadas dentro de un solo contenedor

ESTRUCTURA.

-Las estructuras no tienen métodos ni funciones asociadas con ellas solo almacenan datos
relacionados.
-Puedes tener una estructura llamada “Empleado” que tengan con variable como “nombre,
edad y salario”. Es un ejemplo de lo que puede tener una estructura.
-Una estructura es una colección de variables de diferentes tipos de datos.

2.1. INVESTIGUE LOS LENGUAJES DE PROGRAMACIÓN ORIENTADA A OBJETOS Y SUS

CARACTERÍSTICAS (AL MENOS TRES LENGUAJES DE PROGRAMACIÓN)

De muchos lenguajes de programación tenemos 3 que son muy importante: Java, C#, Python.

-Java: Java es un lenguaje de programación de propósito general y orientado a objetos, sus

características principales son: Sintaxis similar a C++, pero con un enfoque mas estricto y
orientado a objetos, soporta herencia (Encapsulamiento y polimorfosis)

-C# (C Sharp): C# es un lenguaje de programación desarrollado por Microsoft y diseñado por

NET y sus características principales son: Esta basado en las características de C++ basado en su
lenguaje, soporta herencia, encapsulamiento y polimorfosis, tiene gestión memoria automática
a través del recolector de basura.

-Python: Es un lenguaje de programación de alto nivel multiparadigma que incluye un soporte

para la programación orientada a objetos sus características principales son: sintaxis clara y
legible lo que hace que sea fácil de aprender, soporta herencia encapsulamiento y polimorfosis,
gestión automática de memoria a través de recolectado de basura

2.2. DESCRIBA LAS CARACTERÍSTICAS DEL LENGUAJE DE PROGRAMACIÓN PYTHON EN LA

PROGRAMACIÓN ORIENTADO A OBJETOS.

Python es un programa orientada a objetos a continuación se describen algunas de las

siguientes características clave de Python en texto POO:

-Tiene una regla gramatical con una facilidad de uso lo que le facilita a la creación y compresión
de código orientado a objetos.

-Es flexible permite la creación de códigos adaptables y fácil de mantener.

-Herencia y Polimorfosis soporta herencia Python lo que posibilita a la creación de jerarquías

de clases y la reutilización de códigos.

- Encapsulamiento aun que no es tan estricto como en otros lenguajes.

2.3. INVESTIGUE LOS ENTORNOS DE DESARROLLO INTEGRADO PARA EL LENGUAJE DE

PROGRAMACIÓN PYTHON.
Los IDE (Entonos de desarrollo integrando) son herramientas que ofrecen características
integradas para el desarrollo de software. Para Python algunos de los IDE de los mas populares
son:

PYCHARM. - Desarrollado por JetBrains, ofrece un conjunto completo de características,

incluyendo un editor de código inteligente, depurador, integración con control de versiones y
más.

Visual Studio Code(VS code). - Desarrollado por Microsoft, es un editor de código ligero pero
potente con una amplia gama de extensiones para Python, incluyendo finalización de código y
depuración

Spyder. -Especialmente diseñado para científicos y analistas de datos, incluye características

específicas para análisis de datos, como explorador de variables y consola IPython integrada.

2.4. INVESTIGUE A CERCA DE FRAMEWORKS DISPONIBLES PARA EL LENGUAJE DE

PROGRAMACIÓN PYTHON

RESPUESTA. –

Python cuenta con una gran variedad de frameworks que cubre varias áreas de desarrollo web
entre los más populares tenemos: Django, Flask , FastAPI , Pyramid , TensorFlow ,Pytorch.

DJANGO. -Django es un framework web de un nivel alto y de código abierto que fomenta al
desarrollo rápido y limpio. También proporciona una arquitectura MVC(Modelo-Vista-
Controlador).

FLASK. -Flask es un frameworks web ligero y flexible que sigue el principio lo hace mas simple.
También proporciona herramientas para crear aplicaciones web simples y rápidos como
también es lo suficientemente extensible para admitir aplicaciones mas complejas.

FASTAPI. – FastAPI es un frameworks web moderno y de alto rendimiento para construir Apis
con Python. También ofrece un rendimiento excepcional, basada en el uso de códigos.

2.5. UTILIZANDO EL LENGUAJE DE PROGRAMACIÓN PYTHON RESUELVA LOS SIGUIENTES

EJERCICIOS EN PSEUDOCÓDIGO O DIAGRAMA DE FLUJO Y TAMBIÉN LLEVARLO A
CODIFICACIÓN.

a) Algoritmo de ordenación de la burbuja

def bubble_sort(a):
n = len(a)
# Iterar sobre todos los elementos del arreglo
for i in range(n):
# Últimos i elementos ya están ordenados, no necesitamos compararlos
for j in range(0, n-i-1):
# Comparamos los conceptos concecutivos
if a[j] > a[j+1]:
# Intercambiar si están en el orden incorrecto
 a[j], a[j+1] = a[j+1], a[j]

# Ejemplo de uso
a = [11,44,22,33,66,88,55,77]
print("Numero introducidos:", a)
bubble_sort(a)
print("Numeros ordenados:", a)
b) Algoritmo de ordenación Shell

def shell_sort(b):
n = len(b)
intervalo = n // 2
while intervalo > 0:
for i in range(intervalo, n):
temp = b[i]
j=i
while j >= intervalo and b[j - intervalo] > temp:
b[j] = b[j - intervalo]
j -= intervalo
b[j] = temp
intervalo //= 2

# Ejemplo de uso
b = [1,8,2,6,4,6,3,5,6,67]
print("Arreglo original:", b)
shell_sort(b)
print("Arreglo ordenado:", b)
c) Algoritmo de búsqueda secuencial

def busqueda_secuencial(lista, elemento):

for i in range(len(lista)):
if lista[i] == elemento:
return i # Devolver el índice del elemento si se encuentra
return -1 # Devolver -1 si el elemento no está en la lista

# Ejemplo de uso
lista = [1,2,3,4,5,6,7,8]
elemento = 4
indice = busqueda_secuencial(lista, elemento)
if indice != -1:
print("El elemento", elemento, "se encuentra en el índice", indice)
else:
print("El elemento", elemento, "no se encuentra en la lista")
d) Algoritmo de búsqueda Binaria

def busqueda_binaria(lista, elemento):

izquierda = 0
derecha = len(lista) - 1

while izquierda <= derecha:

medio = (izquierda + derecha) // 2
if lista[medio] == elemento:
return medio # Devolver el índice del elemento si se encuentra
elif lista[medio] < elemento:
 izquierda = medio + 1
else:
derecha = medio - 1

return -1 # Devolver -1 si el elemento no está en la lista

# Ejemplo de uso
lista = [1, 2, 3, 4, 5, 6, 7]
elemento = 5
indice = busqueda_binaria(lista, elemento)
if indice != -1:
print("El elemento", elemento, "se encuentra en el índice", indice)
else:
print("El elemento", elemento, "no se encuentra en la lista")

2.6. DESARROLLE EL MÉTODO PARA OBTENER FACTORIAL DE UN NÚMERO

#Primera opcion utilizamos un enfoque iterativo

def factorial_opc1(n):
factorial = 1
for i in range(1, n + 1):
factorial *= i
return factorial

# Ejemplo de uso
numero = 4
resultado = factorial_opc1(numero)
print("la factorial de", numero, "es:", resultado)
#Segunda opcion usamos un enfoque recursiva
def factorial_opc2(n):
if n == 0:
return 1
else:
return n * factorial_opc2(n - 1)

# Ejemplo de uso
numero = 5
resultado = factorial_opc2(numero)
print("la factorial de", numero, "es:", resultado)

2.7. DESARROLLE EL MÉTODO PARA OBTENER LA DIVISIÓN DE DOS NÚMEROS ENTEROS

#divn=dividiendo
#divs=divisor
def division_entera(divn, divs):
# Manejamos la division por 0
if divs == 0:
raise ValueError("No se puede dividir por cero")
 cociente = 0
resto = divn

# El resto pude ser mayor o igual al divisor

while resto >= divs:
resto -= divs
cociente += 1

return cociente, resto

# Ejemplo de uso
divn = 10
divs = 3
cociente, resto = division_entera(divn, divs)
print("El cociente de la división entera de", divn, "por", divs, "es:", cociente)
print("El resto de la división entera de", divn, "por", divs, "es:", resto)

3.1. DADA UNA CLASE PRINCIPAL LLAMADA PAJARO SE DEFINEN LOS ATRIBUTOS Y MÉTODOS
QUE APARECEN EN LA IMAGEN. LOS MÉTODOS REALIZAN LAS SIGUIENTES ACCIONES:

import math
class Pajaro:
def __init__(self, nombre="", posX=0, posY=0):
self.nombre = nombre
self.posX = posX
self.posY = posY

def volar(self, posX, posY):

desplazamiento = math.sqrt(self.posX * posX + self.posY * posY)
return desplazamiento

# Programa principal
if __name__ == "__main__":
# Crear una instancia de la clase Pajaro
pajaro = Pajaro("Piolín", 3, 4)

# Mostrar los atributos del pájaro

print("Nombre del pájaro:", pajaro.nombre)
print("Posición X:", pajaro.posX)
print("Posición Y:", pajaro.posY)

# Llamar al método volar y mostrar el resultado

nuevoX = 5
nuevoY = 6
desplazamiento = pajaro.volar(nuevoX, nuevoY)
print("Desplazamiento del pájaro:", desplazamiento)
#Este programa que cremos llamado PAJARO utliliza los metodos requeridos por el ejercicio
#La clase tambien tiene un metodo que se llama VOLAR usando las formulas adquiridas por la
pregunta
3.2. Mediante programación orientada a objetos defina la clase Producto donde se almacena,
código, nombre y precio. Se pide; diagrama de clases, un constructor sin argumentos, un
constructor con argumentos, instanciar dos objetos de la clase y mostrar cuantos productos
tienen un precio x introducido por teclado.

#Saber contar cuantos productos tiene ese precio usamos 2 objetos de la clase
class Producto:
def __init__(self, codigo="", nombre="", precio=0.0):
self.codigo = codigo
self.nombre = nombre
self.precio = precio

def mostrar_informacion(self):
print("Código:", self.codigo)
print("Nombre:", self.nombre)
print("Precio:", self.precio)

# Instanciar dos objetos de la clase Producto

producto1 = Producto("001", "Camisa", 25.0)
producto2 = Producto("002", "Pantalón", 35.0)

# Mostrar información de los productos

print("Producto 1:")
producto1.mostrar_informacion()
print("\nProducto 2:")
producto2.mostrar_informacion()

# Solicitar al usuario un precio específico

precio_buscar = float(input("\nIntroduce un precio para buscar productos: "))

# Contar cuántos productos tienen el precio introducido

cantidad_productos = 0
if producto1.precio == precio_buscar:
cantidad_productos += 1
if producto2.precio == precio_buscar:
cantidad_productos += 1

print("Cantidad de productos con precio", precio_buscar, ":", cantidad_productos)

3.3. LA EMPRESA "PEQUEÑOS TESOROS", ES UNA EMPRESA DEDICADA A LA VENTA DE ROPA

DE NIÑOS DE 0 A 12 AÑOS. TIENE UNA GRAN GAMA DE PRODUCTOS, QUE INCLUYE DESDE
ROPA DEPORTIVA…..

CODIFICAMOS ESTAS CLASES EN PYTHON

#Con este codigo definimos Producto, Ropa_Deportiva,

#Ropa_Casual y DescuentoVenta
#según el diagrama de clases proporcionado.
class Producto:
def __init__(self, codigo, nombre, precio):
self.codigo = codigo
 self.nombre = nombre
self.precio = precio

class Ropa_Deportiva(Producto):
def __init__(self, codigo, nombre, precio, temporada):
super().__init__(codigo, nombre, precio)
self.temporada = temporada

def descuento(self, cantidad):

if cantidad == 1:
return 0.10
elif cantidad == 3:
return 0.25
elif cantidad >= 6:
return 0.50
else:
return 0

class Ropa_Casual(Producto):
def __init__(self, codigo, nombre, precio, temporada):
super().__init__(codigo, nombre, precio)
self.temporada = temporada

def descuento(self, cantidad):

if cantidad == 1:
return 0.10
elif cantidad == 3:
return 0.25
elif cantidad >= 6:
return 0.50
else:
return 0

class DescuentoVenta:
def __init__(self):
self.ventas = []

def agregar_venta(self, venta):

self.ventas.append(venta)

def obtener_venta_max_descuento(self):
if not self.ventas:
return None

max_descuento = max(self.ventas, key=lambda venta: venta[1])

return max_descuento

def obtener_venta_min_descuento(self):
if not self.ventas:
return None

min_descuento = min(self.ventas, key=lambda venta: venta[1])

return min_descuento

# Crear instancias de cada clase

producto1 = Ropa_Deportiva("001", "Camiseta deportiva", 20, "verano")
producto2 = Ropa_Casual("002", "Camiseta casual", 15, "verano")
producto3 = Ropa_Deportiva("003", "Short deportivo", 30, "verano")
producto4 = Ropa_Casual("004", "Pantalón casual", 25, "verano")
producto5 = Ropa_Deportiva("005", "Chaqueta deportiva", 50, "invierno")
producto6 = Ropa_Casual("006", "Suéter casual", 40, "invierno")

# Realizar ventas y agregarlas a DescuentoVenta

ventas = DescuentoVenta()
ventas.agregar_venta((producto1.nombre, producto1.descuento(1)))
ventas.agregar_venta((producto2.nombre, producto2.descuento(1)))
ventas.agregar_venta((producto3.nombre, producto3.descuento(1)))
ventas.agregar_venta((producto4.nombre, producto4.descuento(1)))
ventas.agregar_venta((producto5.nombre, producto5.descuento(1)))
ventas.agregar_venta((producto6.nombre, producto6.descuento(1)))

# Imprimir la venta con mayor y menor descuento

max_descuento = ventas.obtener_venta_max_descuento()
min_descuento = ventas.obtener_venta_min_descuento()

print("Venta con mayor descuento:", max_descuento)

print("Venta con menor descuento:", min_descuento)

3.4. SE REQUIERE UN PROGRAMA QUE MODELE EL CONCEPTO DE UNA CONDUCTOR. UN

CONDUCTOR POSEE NOMBRE, APELLIDO, NÚMERO de documento de identidad, año de
nacimiento y categoría de la licencia de conducir. La clase debe tener un constructor que
inicialice los valores de sus respectivos atributos.

#Con este codigo creamos la clase constructor con los Tributos:nombre,apellido,documento,etc

class Conductor:
def __init__(self, nombre, apellido, documento, año_nacimiento, categoria_licencia):
self.nombre = nombre
self.apellido = apellido
self.documento = documento
self.año_nacimiento = año_nacimiento
self.categoria_licencia = categoria_licencia

def imprimir_atributos(self):
print("Nombre:", self.nombre)
print("Apellido:", self.apellido)
print("Documento:", self.documento)
print("Año de nacimiento:", self.año_nacimiento)
print("Categoría de licencia:", self.categoria_licencia)

if __name__ == "__main__":
# Crear dos instancias de la clase Conductor
conductor1 = Conductor("Juan", "Pérez", "12345678", 1985, "B")
conductor2 = Conductor("María", "Gómez", "87654321", 1990, "A")

# Mostrar los atributos de cada conductor

print("Conductor 1:")
conductor1.imprimir_atributos()
print("\nConductor 2:")
conductor2.imprimir_atributos()