Lab Lenguajes de Programacion

UCSM Esc. Prof.
de Ingeniería de Sistemas INFORME DE PRÁCTICAS

Setiembre - 2021 LENGUAJES DE
PROGRAMACIÓN I
Práctica Nro. 04: HERENCIA Y

POLIMORFISMO
Elaborado por:
JOSE MANUEL HUAMANI PAUCARA
JACK CARLOS ENRIQUE LAURENCIO MAMANI
RODRIGO ERIC MECHAN CARI
Practica N°04: Herencia y Polimorfismo
PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN I
Presentado por:
JOSE MANUEL HUAMANI PAUCARA

JACK CARLOS ENRIQUE LAURENCIO MAMANI
RODRIGO ERIC MECHAN CARI
2
RECONOCIMIENTOS
El autor del presente informe reconoce y demuestra agradecimientos al ingeniero Diego

Alonso Iquira Becerra, docente de la Universidad Católica de Santa María en el curso de
Lenguajes de Programación I.
PALABRAS CLAVE
Clases
Clase Padre
Clase Hija
Herencia
Herencia Simple
Herencia Múltiple
Polimorfismo
3
ÍNDICE
1. RESUMEN …………………………………………………………………………………5
2. INTRODUCCIÓN .................................................................................................................. 5
3. EXPERIENCIAS DE PRÁCTICA
3.1 HERENCIA SIMPLE ................................................................................................... 6
3.2 HERENCIA MÚLTIPLE............................................................................................ 10
3.3 CREACIÓN DE CLASES POLIMÓRFICAS .......................................................... 111
3.4 POLIMORFISMO CON MÉTODOS DE CLASE ................................................... 133
3.5 POLIMORFISMO CON UNA FUNCIÓN............................................................... 155
4. CONCLUSIONES DE LA PRÁCTICA: ........................................................................... 166
5. EJERCICIOS
5.1 .................................................................................................................................... 16
5.2 .................................................................................................................................... 18
5.3 .................................................................................................................................. 118
5.4 .................................................................................................................................. 139
5.5 .................................................................................................................................... 20
5.6 .................................................................................................................................. 213
6. CONCLUSIONES DE LOS EJERCICIOS: ......................................................................... 23
7. CUESTIONARIO ................................................................................................................. 23
8. BIBLIOGRAFÍA .................................................................................................................. 27
4
1. RESUMEN
En nuestra primera práctica nosotros hemos desarrollado código para aprender sobre
la utilización de tipos de datos agregados por el usuario basados en estructuras y
clases, de la misma forma que hemos podido aprender la forma como se construyen
arreglos de objetos del tipo de estructuras y clases, las estructuras que estamos
trabajando en archivos binarios, persistencia de datos a partir del ingreso de
información a un programa convencional.
2. INTRODUCCIÓN
La potencia de las computadoras nos permite a nosotros manejar grandes volúmenes
de información procesarlos y obtener herramientas que nos permitan tomar decisiones
a futuro, el procesamiento de información es posible a través del acopio de grandes
volúmenes de datos, y posteriormente vamos
5
3. ACTIVIDADES
3.1. HERENCIA SIMPLE

Método constructor del padre:
Para esta primera actividad debemos poner en ejecución el código brindado
por la guía de práctica en la que probamos cómo funciona la herencia de
métodos y en especial el método constructor de la clase padre, en caso la clase
hija no posea un método constructor.
También en este probamos la ejecución de métodos, tanto de la clase padre
como de la clase hija.
import math
class Padre:
def __init__(self):
self.x = 8
print("Constructor clase padre")
print("Esta clase posee un atributo llamado 'x'")
def metodo(self):
print("Ejecutando el método de la clase padre")
print("La suma de 8 y 5 es:",8+5)
class Hija(Padre):
def metHija(self):
print("Método de la clase hija")
print("La raíz cuadrada de 25 es:",math.sqrt(25))
Ana=Hija()
Ana.metodo()
Ana.metHija()
Ejecución:
Constructor clase padre

Esta clase posee un atributo llamado 'x'
Ejecutando el método de la clase padre
La suma de 8 y 5 es: 13
Método de la clase hija
La raíz cuadrada de 25 es: 5.0
6
Método constructor del hijo(a):

En este segundo código brindado por la guía de prácticas poner a prueba un
nuevo código en el que le colocamos un método constructor a la clase hija, en
este también observamos que los atributos del padre también pueden ser
heredados por los hijos.
class Padre:
def __init__(self):
self.x = 8
print("Constructor clase padre")
print("Esta clase posee un atributo llamado 'x'")
def metodo(self):
print("Ejecutando el método de la clase padre")
class Hija(Padre):
def __init__(self):
print("Constructor de la clase hija")
print("Esta clase no posee ningún atributo, pero lo hereda de su
clase padre")
def metHija(self):
print("Método de la clase hija")
Maria=Hija()
Maria.x=100
print("El atributo 'x' ahora será",Maria.x)
Maria.metodo()
Maria.metHija()
Ejecución:
Constructor de la clase hija

Esta clase no posee ningún atributo, pero lo
hereda de su clase padre
El atributo 'x' ahora será 100
Ejecutando el método de la clase padre
Método de la clase hija
7
Clases hijas:
En este código apreciar que una clase padre puede poseer varias clases hijas,
que heredan tanto sus atributos como sus métodos.
class Vehiculo:
n_ruedas = 2
def __init__(self,marca,modelo,placa):
self.marca = marca
self.modelo = modelo
self.placa=placa
def mostrarDatos(self):
print("Marca:",self.marca,"\nModelo:",self.modelo,"\nPlaca:"
,self.placa)
def acelerar(self):
print("Método acelerar")
print("Brm - Brm")
print("Máxima potencia")
def frenar(self):
print("Método frenar")
print("ZzzzZ")
class Moto(Vehiculo):
pass
class Coche(Vehiculo):
pass
C1=Coche("Lamborghini","URUS","1F3-567")
C1.n_ruedas=4
C1.mostrarDatos()
C1.frenar()
C1.acelerar()
print("El coche tiene",C1.n_ruedas,"ruedas\n")
M1=Moto("Suzuki","GSX-S1000GT 2022","4M3-123")
M1.n_ruedas=2
M1.mostrarDatos()
M1.acelerar()
M1.frenar()
print("La moto tiene",M1.n_ruedas,"ruedas")
8
Ejecución:
Marca: Lamborghini
Modelo: URUS
Placa: 1F3-567
Método frenar
ZzzzZ
Método acelerar
Brm - Brm
Máxima potencia
El coche tiene 4 ruedas
Marca: Suzuki
Modelo: GSX-S1000GT 2022
Placa: 4M3-123
Método acelerar
Brm - Brm
Máxima potencia
Método frenar
ZzzzZ
La moto tiene 2 ruedas
9
3.2. HERENCIA MÚLTIPLE

Para el siguiente código debemos saber también que una clase hija puede tener
varios padres, solo es necesario mencionarlos al momento de la creación de la
clase hija, y esta heredara todos los atributos y métodos de ambas clases.
class Persona:
def __init__(self,nombre,edad,sexo,dni):
self.nombre=nombre
self.edad=edad
self.sexo=sexo
self.dni=dni
def hablar(self):
print("Hola! Buenos días")
class Personal():
def trabajar(self):
print("Soy personal de la empresa")
class Mantenimiento(Persona,Personal):
print("Nombre:",self.nombre,"\nEdad:",self.edad,"\nSexo:",se
lf.sexo,"\nDNI:",self.dni)
def labor(self):
print("Trabajo en mantenimiento")
J1=Mantenimiento("Juan Rodriguez",35,"Masculino",12345678)
J1.hablar()
J1.trabajar()
J1.labor()
J1.mostrarDatos()
Ejecución:
Hola! Buenos días

Soy personal de la empresa
Trabajo en mantenimiento
Nombre: Juan Rodriguez
Edad: 35
Sexo: Masculino
DNI: 12345678
10
3.3. CREACIÓN DE CLASES POLIMÓRFICAS

Para hacer uso del polimorfismo debemos de tener como mínimo dos clases
las cuales serán usadas con objetos distintos, sin embargo, estas clases deben
tener uno o varios métodos en común los cuales deben realizar acciones
diferentes. Tal es el caso del siguiente código.
class Tiburon():
def __init__(self,nombre):
self.nombre=nombre
def nadar(self):
print("El tiburón está nadando.")
print("El tiburón se llama",self.nombre)
def nadarHaciaAtras (self):
print("El tiburón no puede nadar hacia atrás, pero puede hun
dirse hacia atrás.")
def esqueleto(self):
print("El esqueleto del tiburón está hecho de cartílago.")
class PezPayaso():
self.nombre=nombre
def nadar(self):
print("El pez payaso está nadando.")
print("El pez payaso se llama",self.nombre)
def nadarHaciaAtras(self):
print("El pez payaso puede nadar hacia atrás.")
print("El esqueleto del pez payaso está hecho de hueso.")
King=Tiburon("King")
King.nadar()
King.nadarHaciaAtras()
King.esqueleto()
print("")
Nemo=PezPayaso("Nemo")
Nemo.nadar()
Nemo.nadarHaciaAtras()
Nemo.esqueleto()
11
Ejecución:
El tiburón está nadando.

El tiburón se llama King
El tiburón no puede nadar hacia atrás, pero puede hundirse
hacia atrás.
El esqueleto del tiburón está hecho de cartílago.
El pez payaso está nadando.

El pez payaso se llama Nemo
El pez payaso puede nadar hacia atrás.
El esqueleto del pez payaso está hecho de hueso.
12
3.4. POLIMORFISMO CON MÉTODOS DE CLASE

Python es un lenguaje que brinda muchas facilidades al momento de
programar, por tal motivo es posible usar bucles obtener valores como objetos
ya sean tanto de una tupla como de una lista. Como se puede apreciar en el
siguiente código se hace uso de un bucle for que recorre la tupla conformada
por tres elementos que en este caso son objetos, y dentro de este bucle ejecuta
sus métodos para cada objeto de la tupla.
class Tiburon():
self.nombre=nombre
def nadar(self):
print("El tiburón está nadando.")
print("El tiburon se llama",self.nombre)
def nadarHaciaAtras (self):
print("El tiburón no puede nadar hacia atrás, pero puede hun
dirse hacia atrás.")
print("El esqueleto del tiburón está hecho de cartílago.")
class PezPayaso():
self.nombre=nombre
def nadar(self):
print("El pez payaso está nadando.")
print("El pez payaso se llama",self.nombre)
def nadarHaciaAtras(self):
print("El pez payaso puede nadar hacia atrás.")
print("El esqueleto del pez payaso está hecho de hueso.")
King=Tiburon("King")
Jack=Tiburon("Jack")
for pez in [King,Nemo,Jack]:
pez.nadar()
pez.nadarHaciaAtras()
pez.esqueleto()
print("")
13
Ejecución:

El tiburón se llama King
El tiburón no puede nadar hacia atrás, pero puede
hundirse hacia atrás.
El pez payaso está nadando.

El pez payaso se llama Nemo
El pez payaso puede nadar hacia atrás.
El esqueleto del pez payaso está hecho de hueso.

El tiburón se llama Jack
El tiburón no puede nadar hacia atrás, pero puede
hundirse hacia atrás.
14
3.5. POLIMORFISMO CON UNA FUNCIÓN

También es posible crear funciones para la ejecución de los métodos de clase.
Incluso también es posible la creación de un objeto dentro de una función.
Como se ve en el siguiente código se hace uso de una función para ejecutar el
método respirar en que a la vez hay polimorfismo entre diferentes clases que
tiene el mismo método en común, pero realizan acciones diferentes.
class PezEspada:
self.nombre=nombre
def respirar(self):
print("Puedo respirar bajo el agua y soy un pez")
print("Hola soy un pez espada y mi nombre es",self.nombre,"\
n")
class PezPayaso:
self.nombre=nombre
def respirar(self):
print("Puedo respirar bajo el agua y soy un pez también")
print("Hola mi soy un pez payaso y mi nombre es",self.nombre
,"\n")
class Persona:
self.nombre=nombre
def respirar(self):
print("No puedo respirar bajo el agua, no soy un pez")
print("Hola soy una persona y mi nombre es",self.nombre,"\n"
)
def funcion(Objeto):
Objeto.respirar()
King=PezEspada("King")
funcion(King)
funcion(Nemo)
Rodrigo=Persona("Rodrigo")
funcion(Rodrigo)
15
Ejecución:
Puedo respirar bajo el agua y soy un pez

Hola soy un pez espada y mi nombre es King
Puedo respirar bajo el agua y soy un pez también

Hola mi soy un pez payaso y mi nombre es Nemo
No puedo respirar bajo el agua, no soy un pez

Hola soy una persona y mi nombre es Rodrigo
4. CONCLUSIONES DE LAS ACTIVIDADES:
4.1. La actividad en si es una guía para mejorar el aprendizaje y poner en

prueba lo aprendido durante la sesión, es por eso que sirven como
guía y son bastante útiles para comprender el funcionamiento de la
herencia y el polimorfismo en Python.
4.2. Las actividades nos muestran todas las facilidades que nos brinda
Python para la creación de clases polimórficas, y la ejecución de sus
diferentes métodos.
4.3. Nos prepara para lograr un óptimo desarrollo de los ejercicios de la

presente guía de práctica.
16
5. EJERCICIOS:
5.1 De acuerdo con el siguiente diagrama, defina la función mostrar () de la clase

Material, así como de la clase Revista (signatura y cuerpo de la función), teniendo
en cuenta que dicha función debe comportarse de manera polimórfica.
#Ejercicio 1
class Material():
def __init__(self, Nombre, NumVol):
self.nombre=Nombre
self.NumVol=NumVol
def mostrar(self):
print(self.nombre, " ",self.NumVol)
class Revista(Material):
def __init__(self,NumRevistas):
self.NumRevistas=NumRevistas
def Mostrar(self):
print(self.NumRevistas)
class Libro(Material):
def __init__(self,numLibros):
self.NumLibros=numLibros
def mostrar(self):
print(self.NumLibros)
x=Revista(19)
x.nombre=("Vogue")
x.NumVol=5
x.Mostrar()
17
5.2 Elabore un programa en Python que implemente la siguiente jerarquía de clases.

Aplique encapsulación, polimorfismo y herencia simple, funciones set y get.
Incluya los atributos y métodos que considere necesarios.
class Figura:
def __init__(self,lados):
self.lados=lados
self.set_vertices(lados)
def mostrar(self):
print("Soy una figura geométrica")
def get_vertices(self):
return self._vertices
def set_vertices(self,valor):
if valor > 2:
self._vertices = valor
vertices = property(get_vertices,set_vertices)
class Cuadrado(Figura):
def mostrar(self):
print("Hola soy un cuadrado, tengo",self.lados,"lados")
print("Tengo",self.get_vertices(),"vertices")
class Circulo(Figura):
def mostrar(self):
print("Hola soy un circulo, tengo",self.lados,"lados")
class Triangulo(Figura):
def mostrar(self):
print("Hola soy un triangulo, tengo",self.lados,"lados")
C1=Triangulo(3)
C1.mostrar()
5.3 A partir de una clase Persona (que contenga como atributos identificación,
nombre, apellido), construya la clase EstudianteIS que extiende a Persona y
agrega como atributo el semestre de matrícula. Use el método __init__() para
inicializar los objetos e investigue el método __str__() para devolver con formato
los datos de la persona cuando se imprima el objeto EstudianteIS. Cuando cree el
objeto EstudianteIS llame desde el método __init__() al constructor de la clase
Persona para enviar los datos de la persona.
18
class Persona():
def __init__(self,identificacion,nombre,apellido):
self.identificacion=identificacion
self.nombre=nombre
self.apellido=apellido
class EstudiantesIS(Persona):
def __init__(self,semestre_de_matricula,x):
self.semestre_de_matricula=semestre_de_matricula
self.x=Persona
def __str__(self):
return +self.nombre+" "+self.apellido+", con identificacion
" +
self.identificacion+" se encuentra en el semestre"+self.semestre_de_
matricula
5.4 Cree una clase Cliente que derive de la clase Persona definida en el ejercicio
anterior e incluya los siguientes atributos: dirección fiscal, código postal, estado.
Añada la operación __init__()
class Persona:
def __init__(self,identif,nombre,apellido):
self.identif=identif
self.nombre=nombre
class Cliente(Persona):
def __init__(self,identif,nombre,apellido,direccionF,codigoP,est
ado):
super().__init__(identif,nombre,apellido)
self.direccionF=direccionF
self.codigoP=codigoP
self.estado=estado
def __str__(self):
texto = "Nombre completo: "+self.nombre+" "+self.apellido+"\
nID: "+str(self.identif)
texto2 = "Dirección fiscal: "+self.direccionF+"\nCódigo post
al: "+self.codigoP+"\nEstado: "+self.estado
return texto+"\n"+texto2
Rod=Cliente(74278127,"Juan","Otto","Calle Venezuela #234 - Caracas",

"04025","Divorciado")
print(Rod)
19
5.5 Cree una clase Empleado que derive de la clase Persona e incluya los siguientes
atributos: Fecha ingreso, cargo, sueldo. Añada la operación __init__(). El sueldo
por defecto es 2500.
class Persona:
def __init__(self,identif,nombre,apellido):
self.identif=identif
self.nombre=nombre
def __init__(self,identif,nombre,apellido,semestre):
self.semestre=semestre
def __str__(self):
texto = "Nombre completo: "+self.nombre+" "+self.apellido+"\nID:
"+str(self.identif)+"\nSemestre matriculado: "+self.semestre
return texto
def __init__(self,identif,nombre,apellido,direccionF,codigoP,estado):
self.direccionF=direccionF
self.codigoP=codigoP
self.estado=estado
def __str__(self):
texto = "Nombre completo: "+self.nombre+" "+self.apellido+"\nID:
"+str(self.identif)
texto2 = "Dirección fiscal: "+self.direccionF+"\nCódigo postal: "
+self.codigoP+"\nEstado: "+self.estado
return texto+"\n"+texto2
class Empleado(Persona):
def __init__(self,identif,nombre,apellido,fechaI,cargo,sueldo=2500):
self.fechaI=fechaI
self.cargo=cargo
self.sueldo=sueldo
print("INFORMACIÓN DEL EMPLEADO")
print("Nombre:",self.nombre,self.apellido)
print("DNI:",self.identif)
print("Fecha de ingreso:",self.fechaI)
print("Cargo:",self.cargo)
print("Sueldo:",self.sueldo)
E1=Empleado(74278817,"Juan","Otto","15/11/2021","Cajero")
E1.mostrarDatos()
20
5.6 Realice modificaciones a las clases para incorporar encapsulación, polimorfismo,

y funciones set y get. Cree objetos para cada una de las clases. Implemente en algunas
de las clases el método __del__ ().
class Persona():
def __init__(self,identificacion,nombre,apellido):
self.nombre=nombre
def set_identificacion(self,identificacion):
def get_identificacion(self,identificacion):
print(self,identificacion)
def set_nombre(self,Nombre):
self.nombre=Nombre
def get_nombre(self):
print(self.nombre)
def set_apellido(self,apellido):
def get_apellido(self):
print(self.apellido)
def __str__(self):
return self.nombre+" "+self.apellido+", con identificacion "
+self.identificacion
def __init__(self,semestre_de_matricula):
x=Persona
x.__init__
def set_semestre_de_matricula(self,semestre_de_matricula):
def get_semestre_de_matricula(self):
print(self.semestre_de_matricula)
def __str__(self):
return self.nombre+" "+self.apellido+", con identificacion "
+self.identificacion+" se encuentra en el" +self.semestre_de_matricu
la+"semestre"
def __init__(self,direccion_fiscal,codigo_postal,estado):
self.direccion_fiscal=direccion_fiscal
self.codigo_postal=codigo_postal
self.estado=estado
def set_direccion_fiscal(self,direccion_fiscal):
def get_direccion_fiscal(self):
print(self.direccion_fiscal)
def set_codigo_postal(self, codigo_postal):
def get_codigo_postal(self):
21
print(self.codigo_postal)
def set_estado(self,estado):
self.estado=estado
def get_estado(self):
def __init__(self,direccion_fiscal,codigo_postal,estado):
self.estado=estado
def set_direccion_fiscal(self,direccion_fiscal):
def get_direccion_fiscal(self):
print(self.direccion_fiscal)
def set_codigo_postal(self, codigo_postal):
def get_codigo_postal(self):
print(self.codigo_postal)
def set_estado(self,estado):
self.estado=estado
def get_estado(self):
print(self.estado)
def __del__(self):
del (self.direccion_fiscal, self.codigo_postal, self.estado)
def __str__(self):
return "Direccion Fiscal"+self.direccion_fiscal+"\n, El codi
go Postal es:"+self.codigo_postal+"\n, en el estado de"+self.estado
class Empleado(Persona):
def __init__(self,Fecha_ingreso,cargo,sueldo=2500):
self.fecha_ingreso=Fecha_ingreso
self.cargo=cargo
self.sueldo=sueldo
def set_fecha_ingreso(self,fecha_ingreso):
self.fecha_ingreso=fecha_ingreso
def get_fecha_ingreso(self):
print(self.fecha_ingreso)
def set_cargo(self,cargo):
self.cargo=cargo
def get_cargo(self):
print(self.cargo)
def set_sueldo(self,sueldo=2500):
self.sueldo=sueldo
def get_sueldo(self):
print(self.sueldo)
def __str__(self):
return self.nombre+" "+self.apellido+" \n, con la fecha de i
ngreso "+self.fecha_ingreso+"\n con el cargo de: "+self.cargo+"\n co
n el sueldo de: "+self.sueldo
C1=Persona(412342,"Juan","Carlos")
C2=EstudiantesIS("Cuarto")
C3=Cliente("Av. Arequipa",342342,"Perú")
C4=Empleado("28/09/2021","Empleado")
22
6. CONCLUSIONES DE LOS EJERCICIOS:
6.1. Ejercicio 1: Pudimos apreciar que gracias a esta clase "Figura" como clase
padre podemos asignar los lados de las figuras ahorrando celdas de código y
tiempo nuestro.
6.2. Ejercicio 2: Ahora en este se pudo apreciar al igual que en el anterior que se
puede ahorrar celdas de código para asignar nombre y el número de volumen
6.3. Ejercicio 3,4,5: En estos ejercicios se aprecian que las clases "EstudianteIS",
"Cliente" y "Empleado" ahorran celdas de código gracias a que heredan de la
clase "Persona" los atributos Nombre, Apellido, Identificacion y otros.
6.4. Ejercicio 6: En este ejercicio se asimila mas a los 3 anteriores con la

diferencia que a este se le añade las funciones get y set para todos los atributos
existentes, esto para poder modificar un atributo en específico sin la necesidad
de tener que colocar los demás atributos de nuevo además de mostrar el
atributo en concreto que queramos.
7. CUESTIONARIO
a) ¿Qué es la herencia?
La herencia permite que una clase se defina a partir de otra, esto comparte métodos
y los datos, además se pueden definir nuevos métodos o remplazar los ya
existentes.
b) ¿Cómo se relaciona la herencia con la programación orientada a

objetos?
En programación orientada a objetos la herencia es uno de los mecanismos más
utilizados para desarrollar software
c) ¿Qué ventajas ofrece el uso de la herencia?

Las ventajas de la herencia son que permite que se basen clases nuevas en unas
que ya existían y utilizar métodos y atributos de estos, así reutilizar de manera
más óptima el software y no tener que crear una clase nueva para cada cosa sino
reutilizar atributos de las ya existentes
d) ¿Cómo hacemos uso de la herencia?

Creando una clase y luego usando el nombre en el parámetro de la clase que
heredara permite a los programadores crear una lase general primero y luego más
tarde crear clases más enfocadas
23
e) ¿De qué forma se implementa la herencia en Python?

Pasando como parámetro la clase de la cual se quiere heredar los métodos y
atributos para que en caso de que tengan atributos similares no tener que crear
muchas clases
f) ¿Qué es la herencia simple?

Se le dice herencia simple cuando una clase hija hereda los atributos y métodos
de una sola clase padre.
g) ¿Brinden un ejemplo de uso de herencia simple?
class profesionales:
def _init_(self, especialidad, edad, nombre, dni):
self.especialidad = especialidad
self.edad = edad
self.nombre = nombre
self.dni = dni
def observar(self):
pass
def moverse(self):
pass
def describeme(self):
print("soy un ingeniero de sistemas y me llamo ", type(self)._name_)
class programador(profesionales):
def hablar(self):
print("hola")
def caminar(self):
print("Caminando")
h) ¿Qué es la herencia múltiple?
Se le conoce como herencia múltiple cuando una clase hija hereda atributos de
varias clases en lugar de una.
24
i) ¿Brinden un ejemplo de uso de herencia múltiple?

# Una clase que hereda de la superclase llamada Persona, la subclase se llama
Ingenieros
# que tienes dos atributos propios
class Persona: # Superclase
# Creamos los atributos
codigo=""
nombre=" " # Aqui debe haber mas de 20 espacios para que
entre al while
genero=""
# Creammos metodos
def inseper(self): #Funcion para insertar persona
opc=False # creamos la variable opc para poder ingresar el while siguiente
while opc==False:
self.codigo=input("Ingrese su codigo del 0-9 y 4 digitos: ")
while len(self.codigo)!=4: # verifica que el codigo sea de 4 caracteres
self.codigo=input("Ingrese entr 0-9 y solo 4 dígitos: ")
opc=self.codigo.isdigit() # isdigit verifica que sea caracter númerico
while len(self.nombre)<1 or len(self.nombre)>20 : # verificmos que la
cantidad de caracteres no mayor de 20
self.nombre=input("Ingresar nombre (max. 20 caracteres): ")
while len(self.genero)<1 or len(self.genero)>2: # verificamos que la
cantidad de carateres no sea mayor a 1
while self.genero!="M" and self.genero!="m" and self.genero!="F" and
self.genero!="f":
self.genero=input("Ingrese genero (max.1 caracter): ")
class Ingenieros(Persona): # Ingenieros(subclase) hereda de Persona(superclase)

# Atributos
capitulo=" "
sueldo=-1
# Metodos
25
def inseing(self):
opc=False
def inseing(self):
opc=False
while opc==False:
self.capitulo=input("Ingrese capitulo: ")
opc=self.capitulo.isalpha()
while self.sueldo<0:
self.sueldo=int(input("Ingrse sueldo: "))
def mostrar(self):
print("El codigo ingresado es: ", obj.codigo)
print("El nombre ingresado es: ", obj.nombre)
print("El genero ingresado es: ", obj.genero)
print("El capitulo es: ", obj.capitulo)
print("El sueldo es: ", obj.sueldo,"\n")
# Rutina principal
obj=Ingenieros() # solo crea objeto de la subclase
lista=["\n1. Ingesar datos","2. Mostrar datos","3. FIN"]
for i in lista:
print(i)
opc=int(input("Escoger una opcion: (1-2-3): "))
while opc>=1 and opc<=2:
if opc==1:
print("\nIngrese datos")
obj.inseper() # obj puede usar metodo de la superclase Persona
obj.inseing() # obj puede usar metodo de la subclase Ingenieros
if opc==2:
print("\nMostrar datos")
obj.mostrar()
for i in lista:
print(i)
26
opc=int(input("Escoger una opción: (1-2-3): " ))
print ("Fin del programa")
j) ¿Qué es el polimorfismo?
Se le conoce como polimorfismo cuando se puede acceder a diferentes clases
desde el mismo interfaz
k) ¿Brinden un ejemplo de uso de polimorfismo?
class Animal:
def hablar(self):
pass
class Perro(Animal):
def hablar(self):
print("Guau!")
class Gato(Animal):
def hablar(self):
print("Miau!")
for animal in Perro(), Gato():
animal.hablar()
8. BIBLIOGRAFÍA
1. Fernández Montoro, Arturo, "Python 3 al Descubierto", 2da Edición, Editorial
ALFAOMEGA, México, Año 2013.
2. Horstmann, Cay S., Necaise, Rance D. "Python for Everyone", 2nd Edition, John
Wiley & Sons, Inc., New Jersey, Año 2014.
3. Ascher, David, Lutz, Mark, "Learning Python", 2da Edición, O’Reilly Media,
Inc., Sebastopol, CA, Año 2003.
4. Barry, Paul, Griffiths, David, "Head First Programming", O’Reilly Media, Inc.,
Sebastopol, CA, Año 2009
27

Lab Lenguajes de Programacion

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lab Lenguajes de Programacion

Cargado por

Copyright:

Formatos disponibles

UCSM Esc. Prof.

de Ingeniería de Sistemas INFORME DE PRÁCTICAS

Práctica Nro. 04: HERENCIA Y

PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN I

JOSE MANUEL HUAMANI PAUCARA

El autor del presente informe reconoce y demuestra agradecimientos al ingeniero Diego

3.1. HERENCIA SIMPLE

Constructor clase padre

Método constructor del hijo(a):

Constructor de la clase hija

3.2. HERENCIA MÚLTIPLE

Hola! Buenos días

3.3. CREACIÓN DE CLASES POLIMÓRFICAS

El tiburón está nadando.

El pez payaso está nadando.

3.4. POLIMORFISMO CON MÉTODOS DE CLASE

El tiburón está nadando.

El pez payaso está nadando.

El tiburón está nadando.

3.5. POLIMORFISMO CON UNA FUNCIÓN

Puedo respirar bajo el agua y soy un pez

Puedo respirar bajo el agua y soy un pez también

No puedo respirar bajo el agua, no soy un pez

4. CONCLUSIONES DE LAS ACTIVIDADES:

4.1. La actividad en si es una guía para mejorar el aprendizaje y poner en

4.3. Nos prepara para lograr un óptimo desarrollo de los ejercicios de la

5.1 De acuerdo con el siguiente diagrama, defina la función mostrar () de la clase

5.2 Elabore un programa en Python que implemente la siguiente jerarquía de clases.

Rod=Cliente(74278127,"Juan","Otto","Calle Venezuela #234 - Caracas",

5.6 Realice modificaciones a las clases para incorporar encapsulación, polimorfismo,

6. CONCLUSIONES DE LOS EJERCICIOS:

6.4. Ejercicio 6: En este ejercicio se asimila mas a los 3 anteriores con la

b) ¿Cómo se relaciona la herencia con la programación orientada a

c) ¿Qué ventajas ofrece el uso de la herencia?

d) ¿Cómo hacemos uso de la herencia?

e) ¿De qué forma se implementa la herencia en Python?

f) ¿Qué es la herencia simple?

g) ¿Brinden un ejemplo de uso de herencia simple?

h) ¿Qué es la herencia múltiple?

i) ¿Brinden un ejemplo de uso de herencia múltiple?

class Ingenieros(Persona): # Ingenieros(subclase) hereda de Persona(superclase)

k) ¿Brinden un ejemplo de uso de polimorfismo?

También podría gustarte