Objetos
Clases
Las clases son los modelos sobre los cuáles se construirán nuestros objetos.
Propiedades
son las características intrínsecas del objeto. Éstas, se representan a modo de variables, solo que técnicamente, pasan a denominarse propiedades:
Metodos
Son funciones que técnicamente se denominan métodos, y representan acciones propias que puede realizar el objeto.
class Persona():
nombre = ""
apellido = ""
direccion = ""
telefono = ""
activo = True
def agregarPersona(self):
self.nombre = "Jaider"
self.apellido = "Quintero"
self.direccion = "Km 1"
self.telefono = "3176548810"
self.activo = True
def mostrarPersona(self):
print(f"Nombre: {self.nombre}")
print(f"Apellido: {self.apellido}")
print(f"Direccion: {self.direccion}")
print(f"Telefono: {self.telefono}")
print(f"Activo: {self.activo}")
def inactivoPersona(self):
self.activo = False
Para este caso tenemos tres métodos:
agregarPersona(self)
mostrarPersona(self)
inactivoPersona(self)
Deben imperativamente llevar el parámetro (self).
Objetos
Las clases por sí mismas, no son más que modelos que nos servirán para crear objetos en concreto. Podemos decir que una clase, es el razonamiento abstracto de un objeto, mientras que el objeto, es su materialización. A la acción de crear objetos, se la denomina instanciar una clase y dicha instancia, consiste en asignar la clase, como valor a una variable:
Ejemplo:
class Persona():
nombre = ""
apellido = ""
direccion = ""
telefono = ""
activo = True
def agregarPersona(self):
self.nombre = "Jaider"
self.apellido = "Quintero"
self.direccion = "Km 1"
self.telefono = "3176548810"
self.activo = True
def mostrarPersona(self):
print(f"Nombre: {self.nombre}")
print(f"Apellido: {self.apellido}")
print(f"Direccion: {self.direccion}")
print(f"Telefono: {self.telefono}")
print(f"Activo: {self.activo}")
def inactivoPersona(self):
self.activo = False
p1 = Persona()
p1.agregarPersona()
p1.nombre = "Nico"
p1.inactivoPersona()
p1.mostrarPersona()
Accediendo a los métodos y propiedades de un objeto
Para acceder al método de una clase, se hace
p1 = Persona() => Se instancia la clase y luego,
p1.agregarPersona() => \<nombreDelObjeto>.\<nombreDelMetodo>() => Se ejecuta el método.
p1.nombre = "Nico" => Se cambia el valor a una propiedad por fuera de la clase y dentro de la clase se cambia con self.nombre = "Nico".
Inicialización
Si desea asignar atributos de objetos en el momento de la creación, necesita el método especial de inicialización de objetos de Python __init__():
def __init__(self):
self.nombre = input("Ingrese el Nombre ")
self.apellido = input("Ingrese el Apellido ")
self.direccion = input("Ingrese la Direccion ")
self.telefono = input("Ingrese la Cedula ")
A esto se le denomina el constructor de la clase, lo que indica que una vez que se instancia la clase, se ejecutaría automaticamente este método.
class Persona():
nombre = ""
apellido = ""
direccion = ""
telefono = ""
activo = True
def __init__(self):
self.nombre = input("Ingrese el Nombre ")
self.apellido = input("Ingrese el Apellido ")
self.direccion = input("Ingrese la Direccion ")
self.telefono = input("Ingrese la Cedula ")
def agregarPersona(self):
self.nombre = "Jaider"
self.apellido = "Quintero"
self.direccion = "Km 1"
self.telefono = "3176548810"
self.activo = True
def mostrarPersona(self):
print(f"Nombre: {self.nombre}")
print(f"Apellido: {self.apellido}")
print(f"Direccion: {self.direccion}")
print(f"Telefono: {self.telefono}")
print(f"Activo: {self.activo}")
def inactivoPersona(self):
self.activo = False
p1 = Persona()
p1.agregarPersona()
p1.nombre = "Nico"
p1.inactivoPersona()
p1.mostrarPersona()
En el ejemplo anterior, cada vez que instanciemos el objeto, se ejecuta el método __init__(self): es decir que captura el valor de cada una de las propiedades, a excepción de la propiedad activo.
Cuando se instancia la clase, no enviamos parámetros, por eso __init__(self) solo lleva el parámetro self.
Cambiemos el ejemplo enviando los valores como parametros, desde donde se instancia la clase.
class Persona():
activo = True
def __init__(self, nombre, apellido, direccion, telefono):
self.nombre = nombre
self.apellido = apellido
self.direccion = direccion
self.telefono = telefono
def mostrarPersona(self):
print(f"Nombre: {self.nombre}")
print(f"Apellido: {self.apellido}")
print(f"Direccion: {self.direccion}")
print(f"Telefono: {self.telefono}")
print(f"Activo: {self.activo}")
def inactivoPersona(self):
self.activo = False
def inicio():
nombre = input("Ingrese el Nombre ")
apellido = input("Ingrese el Apellido ")
direccion = input("Ingrese la Direccion ")
telefono = input("Ingrese la Cedula ")
p1 = Persona(nombre, apellido, direccion, telefono)
p1.nombre = "Nico"
p1.inactivoPersona()
p1.mostrarPersona()
if __name__ == "__main__":
inicio()
Encapsulación
Es exponer solo los atributos de clase que el usuario necesita, para ello se usan propiedades provadas. Para declarar una propiedad de la clase se utiliza doble guión bajo en el nombre de dicha propiedad. Esto con el fin de que solo se pueda cambiar el valor dentro de la clase.
Ejemplo: Si deseo contemplar la propiedad activo sea privado, entonces utilizo la siguiente sintaxis.
class Persona():
__activo = True
def __init__(self, nombre, apellido, direccion, telefono):
self.nombre = nombre
self.apellido = apellido
self.direccion = direccion
self.telefono = telefono
def mostrarPersona(self):
print(f"Nombre: {self.nombre}")
print(f"Apellido: {self.apellido}")
print(f"Direccion: {self.direccion}")
print(f"Telefono: {self.telefono}")
print(f"Activo: {self.__activo}")
def inactivoPersona(self):
self.__activo = False
def inicio():
nombre = input("Ingrese el Nombre ")
apellido = input("Ingrese el Apellido ")
direccion = input("Ingrese la Direccion ")
telefono = input("Ingrese la Cedula ")
p1 = Persona(nombre, apellido, direccion, telefono)
p1.nombre = "Nico"
p1.__activo = False # Muy a pesar que estoy cambiando el valor de la propiedad, hace caso omiso y no lo cambio, porque es privada y esta protegida
p1.mostrarPersona()
if __name__ == "__main__":
inicio()
En la instrucción p1.__activo = False , muy a pesar que estoy cambiando el valor de la propiedad, hace caso omiso y no lo cambio, porque es privada y esta protegida.
Getters y Setters
Algunos lenguajes orientados a objetos admiten atributos de objetos privados a los que no se puede acceder directamente desde el exterior. Entonces, los programadores pueden necesitar escribir métodos getter y setter para leer y escribir los valores de tales atributos privados.
class Persona():
__activo = True
def __init__(self, nombre, apellido, direccion, telefono):
self.__nombre = nombre
self.__apellido = apellido
self.__direccion = direccion
self.__telefono = telefono
def get_nombre(self):
return (self.__nombre)
def set_nombre(self, nombre):
self.__nombre = nombre
def get_apellido(self):
return (self.__apellido)
def set_apellido(self, apellido):
self.__apellido = apellido
def get_direccion(self):
return (self.__direccion)
def set_direccion(self, direccion):
self.__direccion = direccion
def get_telefono(self):
return (self.__telefono)
def set_telefono(self, telefono):
self.__telefono = telefono
def mostrarPersona(self):
print(f"Nombre: {self.__nombre}")
print(f"Apellido: {self.__apellido}")
print(f"Direccion: {self.__direccion}")
print(f"Telefono: {self.__telefono}")
print(f"Activo: {self.__activo}")
def inactivoPersona(self):
self.__activo = False
def inicio():
nombre = input("Ingrese el Nombre ")
apellido = input("Ingrese el Apellido ")
direccion = input("Ingrese la Direccion ")
telefono = input("Ingrese la Cedula ")
p1 = Persona(nombre, apellido, direccion, telefono)
# p1.nombre = "Nico" No usaria esta instruccion para cambiar el valo de nombre
# p1.__nombre = "Nicole"
p1.set_nombre("NiCo") # En su lugar uso este metodo
print(p1.get_nombre())
p1.inactivoPersona()
p1.mostrarPersona()
if __name__ == "__main__":
inicio()
Propiedades para acceso a atributos
La solución Pythonic para la privacidad de atributos es usar propiedades .
nombre = property(get_nombre, set_nombre)
apellido = property(get_apellido, set_apellido)
direccion = property(get_direccion, set_direccion)
telefono = property(get_telefono, set_telefono)
Con esta asignación podemos utilizar las diferentes propiedades para geters como para seters.
Primer Método
class Persona():
__activo = True
def __init__(self, nombre, apellido, direccion, telefono):
self.__nombre = nombre
self.__apellido = apellido
self.__direccion = direccion
self.__telefono = telefono
def get_nombre(self):
return (self.__nombre)
def set_nombre(self, nombre):
self.__nombre = nombre
def get_apellido(self):
return (self.__apellido)
def set_apellido(self, apellido):
self.__apellido = apellido
def get_direccion(self):
return (self.__direccion)
def set_direccion(self, direccion):
self.__direccion = direccion
def get_telefono(self):
return (self.__telefono)
def set_telefono(self, telefono):
self.__telefono = telefono
nombre = property(get_nombre, set_nombre)
apellido = property(get_apellido, set_apellido)
direccion = property(get_direccion, set_direccion)
telefono = property(get_telefono, set_telefono)
def mostrarPersona(self):
print(f"Nombre: {self.__nombre}")
print(f"Apellido: {self.__apellido}")
print(f"Direccion: {self.__direccion}")
print(f"Telefono: {self.__telefono}")
print(f"Activo: {self.__activo}")
def inactivoPersona(self):
self.__activo = False
def inicio():
nom = input("Ingrese el Nombre ")
ape = input("Ingrese el Apellido ")
dire = input("Ingrese la Direccion ")
tel = input("Ingrese la Cedula ")
p1 = Persona(nom, ape, dire, tel)
p1.nombre = 'NiCo'
print(p1.nombre)
p1.inactivoPersona()
p1.mostrarPersona()
if __name__ == "__main__":
inicio()
Segundo Método
Se realiza este codigo por cada propiedad
@property
def nombre(self):
return (self.__nombre)
@nombre.setter
def nombre(self, nombre):
self.__nombre = nombre
Codigo:
class Persona():
__activo = True
def __init__(self, nombre, apellido, direccion, telefono):
self.__nombre = nombre
self.__apellido = apellido
self.__direccion = direccion
self.__telefono = telefono
@property
def nombre(self):
return (self.__nombre)
@nombre.setter
def nombre(self, nombre):
self.__nombre = nombre
@property
def apellido(self):
return (self.__apellido)
@apellido.setter
def apellido(self, apellido):
self.__apellido = apellido
@property
def direccion(self):
return (self.__direccion)
@direccion.setter
def direccion(self, direccion):
self.__direccion = direccion
@property
def telefono(self):
return (self.__telefono)
@telefono.setter
def telefono(self, telefono):
self.__telefono= telefono
def mostrarPersona(self):
print(f"Nombre: {self.__nombre}")
print(f"Apellido: {self.__apellido}")
print(f"Direccion: {self.__direccion}")
print(f"Telefono: {self.__telefono}")
print(f"Activo: {self.__activo}")
def inactivoPersona(self):
self.__activo = False
def inicio():
nom = input("Ingrese el Nombre ")
ape = input("Ingrese el Apellido ")
dire = input("Ingrese la Direccion ")
tel = input("Ingrese la Cedula ")
p1 = Persona(nom, ape, dire, tel)
p1.nombre = 'NiCo'
print(p1.nombre)
p1.inactivoPersona()
p1.mostrarPersona()
if __name__ == "__main__":
inicio()
Empaquetar y Desempaquetar
Usamos dos operadores * (para tuplas) y ** (para diccionarios).
Analicemos el siguiente ejemplo:
""" **************** Forma Normal ******** """
def mostrarPersonas():
listaPersonas = ["Jaider Quintero", "Docente", 1500000]
print(listaPersonas[0])
print(listaPersonas[1])
print(listaPersonas[2])
def inicio():
mostrarPersonas()
if __name__ == "__main__":
inicio()
Para poder obtener la información de listaPersona(), es necesario utilizar los sub indices
listaPersonas[0]
listaPersonas[1]
listaPersonas[2]
y esto no está mal, pero hay momentos en los que no recordamos que información contiene cada sub indice o pueden ser tantos que es díficil tenerlo de presente.
Por ello podemos usar el siguiente ejemplo para ser mas descriptivo en el uso de la gestión de la lista.
""" **************** Empaquetar y desempaquetar ******** """
def mostrarPersonas():
listaPersonas = ["Jaider Quintero", "Docente", 1500000]
(nombre, cargo, salario) = listaPersonas
print(nombre)
print(cargo)
print(salario)
""" ******* Otra forma de desempaquetar ****** """
(nomb, *personas) = listaPersonas
print(nomb)
print(personas)
def inicio():
mostrarPersonas()
if __name__ == "__main__":
inicio()
Las asignaciones de dedempaquetado se presenta en la siguiente imagen.
Tambien es aplicables a las tuplas, y se trata de la misma forma.
""" **************** Empaquetar y desempaquetar ******** """
def mostrarPersonas():
listaPersonas = ("Jaider Quintero", "Docente", 1500000)
(nombre, cargo, salario) = listaPersonas
print(nombre)
print(cargo)
print(salario)
""" ******* Otra forma de desempaquetar ****** """
(nomb, *personas) = listaPersonas
print(nomb)
print(personas)
def inicio():
mostrarPersonas()
if __name__ == "__main__":
inicio()
Aplicacion de Empaquetado y Desempaquetado a Funciones de Listas o Tuplas
""" **************** Empaquetar y Desempaquetar mediante
Funciones con Listas o Tuplas ************* """
def mostrarPersonas(*personas):
print(personas)
""" Otra forma de mostrar """
for item in personas:
print(item)
def inicio():
listaPersonas = ["Jaider Quintero", "Docente", 1500000]
mostrarPersonas(listaPersonas)
if __name__ == "__main__":
inicio()
Aplicacion de Empaquetado y Desempaquetado a Funciones de Diccionarios
""" **************** Empaquetar y Desempaquetar mediante
Funciones con Diccionarios ************* """
def mostrarPersonas(**personas):
print(personas["nombre"])
print(personas["cargo"])
print(personas["salario"])
""" Otra forma de mostrar """
for key in personas:
print(f"{key}: {personas[key]}")
""" Otra forma de mostrar """
for (key, value) in personas.items():
print(f"{key}: {value}")
def inicio():
mostrarPersonas(nombre="Jaider Quintero", cargo="Docente", salario=1500000)
if __name__ == "__main__":
inicio()
Actividades
-
Combinemos las clases con las listas, contemplando que deseamos introducir n numeros de personas con las mismas propiedades hasta que el usuario no desee seguir ingresando personas.
-
Crear un menú, utilizando objetos objetos diccionarios y tuplas, segun lo visto en clases y crear las siguientes opciones:
Crear Estudiante
Listar Estudiante (Utilizando la forma de iteración o ciclos para mostrar
Buscar Estudiante
Eliminar Estudiante
La estructura de los estudiantes , debe estar contenida en una lista de diccionario, que permita la siguiente organización.
Nombre Estudiante Programa Semestre Jaider Quintero Ing de Sistemas 9 Luís Ortiz Ing Mecánica 10 Maite Martinez Contaduría Publica 8 Luisa Julio Psicología 7
-
Si no puede visualizar en forma de tabla, puede utilizar la forma:
Estudiante 1
Nombre Estudiante: "Jaider Quintero"
Programa: "Ing de Sistemas"
Semestre: 9
Estudiante 2
Nombre Estudiante: "Luís Ortiz"
Programa: "Ing Mecánica"
Semestre: 10
Estudiante 3
Nombre Estudiante: "Maite Martinez"
Programa: "Contaduría Publica"
Semestre: 8
Estudiante 4
Nombre Estudiante: "Luisa Julio"
Programa: "Psicología"
Semestre: 7
-
Utilice clases, para optimizar esta estructura.
-