Programación Orientada a Objeto en Python 3

1. Programación estructurada vs POO

Caso práctico: administrar los clientes de una tienda mediante su dni

Mediante programación estructurada:

clientes = [

{‘Nombre’: ‘Charlie’,  ‘Apellidos’:‘Sánchez Ortega’,     ‘dni’:‘11111111A’},

{‘Nombre’: ‘Juan’,      ‘Apellidos’:‘Sanchez González’, ‘dni’:‘22222222B’}

]

Función Mostrar_Cliente:

def mostrar_cliente(clientes, dni):

for c in clientes:

if (dni == c[‘dni’]):

print(‘{} {}’.format(c[‘Nombre’],c[‘Apellidos’]))

return

print(‘Cliente no encontrado’)

mostrar_cliente(clientes, ‘11111111A’)

Charlie Sánchez Ortega

Función Borrar_Cliente:

def borrar_cliente(clientes, dni):

for i,c in enumerate(clientes):

if (dni == c[‘dni’]):

del( clientes[i] )

print(str(c),”> BORRADO”)

return

print(‘Cliente no encontrado’)

borrar_cliente(clientes,‘22222222B’)

{‘dni’: ‘22222222B’, ‘Nombre’: ‘Juan’, ‘Apellidos’: ‘Sánchez González’} > BORRADO

clientes

[{‘Apellidos’: ‘Sánchez Ortega’, ‘Nombre’: ‘Charlie’, ‘dni’: ‘11111111A’}]

 

Mediante programación orientada a objetos:

class Cliente:

def __init__ (self, dni, nombre, apellidos):

self.dni = dni

self.nombre = nombre

self.apellidos = apellidos

def __str__(self):

return ‘{} {}’.format(self.nombre,self.apellidos)

class Empresa:

def __init__(self, clientes=[]):

self.clientes = clientes:

def mostrar_cliente(self, dni=None):

for c in self.clientes:

if c.dni = dni:

print(C)

return

print(“Clientes no encontrado”)

def borrar_cliente(self, dni=None):

for i,c in enumerate(self.clientes):

if c.dni = dni:

del(self.clientes[i])

print(str(c),”> BORRADO”)

return

print(“Cliente no encontrado”)

# Creación de clientes

charlie = Cliente(nombre=”Charlie”,apellidos=”Sánchez Ortega”,dni=”11111111A”)

juan = Cliente(“22222222B”,”Juan”,”Sánchez González”)

# Creación de empresa

empresa = Empresa(clientes=[charlie,juan])

# Mostrar un cliente

empresa.mostrar_cliente(dni=”11111111A”)

Charlie Sánchez Ortega

# Borrar un cliente

empresa.borrar_cliente(“22222222B”)

Juan Sánchez González > BORRADO

 

2. Clases y objetos

# Definir una clase : esta es como un molde para crear objetos

class Galleta:

pass

una_galleta = Galleta() # una_galleta es una instancia de la clase  Galleta (objeto)

otra_galleta = Galleta()

3. Atributos y métodos de clase

class Galleta:

# O este atributo es común en todos los objetos de la clase Galleta

chocolate = False

una_galleta = Galleta()

# Definir el atributo sabor fuera de la instancia

una_galleta.sabor = “Salado”

una_galleta.color = “Marrón”

g = Galleta()

g.chocolate

False

Ahora haciendo uso de __init__ self

class Galleta():

chocolate = False

def __init__(self, sabor=None, forma=None):

self.sabor = sabor

self.forma = forma

if sabor is not None and forma is not None:

print(“Se acaba de crear una galleta {} y {}”.format(sabor,forma))

def chocolatear(self):

self.chocolate = True

def tiene_chocolate(self):

if (self.chocolate):

print(“Soy una galleta chocolateada :-D”)

else:

print(“Soy una galleta sin chocolate :-(“)

g = Galleta(“salada”,“cuadrada”)

Se acaba de crear una galleta salada cuadrada

4. Métodos especiales

class Pelicula:

# Constructor de clase

def __init__(self,titulo,duracion,lanzamiento):

self.titulo = titulo

self.duracion = duracion

self.lanzamiento = lanzamiento

print(“Se ha creado la película”, self.titulo)

# Destructor de clase

def __del__(self):

print(“Se está borrando la película”,self.titulo)

# Redefinir el método string

def __str__(self):

return “{} lanzada en {} con una duración de {} minutos”. format(self.titulo,self.lanzamiento,self.duracion)

# Redefinir el método length

def __len__(self):

return self.duracion

p = Película(“El Padrino”,175,1972)

str(p)

‘El Padrino lanza en 1972 con una duración de 175 minutos’

len(p)

175

5. Objetos dentro de objetos

class Pelicula:

# Constructor de clase

def __init__(self, titulo, duracion, lanzamiento):

self.titulo = titulo

self.duracion = duracion

self.lanzamiento = lanzamiento

print(‘Se ha creado la película:’,self.titulo)

def __str__(self):

return ‘{} ({})’.format(self.titulo, self.lanzamiento)

class Catalogo:

peliculas = []

def __init__(self,peliculas=[]):

self.peliculas = peliculas

def agregar(self,p):

self.pelicula.append(p)

def mostrar(self):

for p in self.peliculas:

print(p)

p = Pelicula(“El Padrino”,175,1972)

c = Catalogo([p])

Se ha creado la película: El Padrino

c.mostrar()

El Padrino (1972)

c.agregar(Pelicula(“El Padrino: Parte 2”,202,1974))

Se ha creado la pelicula: El Padrino: Parte 2

c.mostrar()

El Padrino (1972)

El Padrino: Parte 2 (1974)

 

6. Encapsulación de atributos y métodos

La encapsulación es una técnica que se utiliza para “esconder” los atributos y métodos de una clase, haciendo que éstos no sean accesibles directamente desde el exterior.

class Ejemplo:

__atributo_privado = “Soy un atributo inalcanzable desde fuera”

def __metodo_privado(self):

print(“Soy un método inalcanzable desde fuera”)

e = Ejemplo()

e.__metodo_privado

AttributeError: ‘Ejemplo’ object has no attribute ‘__metodo_privado’

Pero podríamos crear un método público que hiciera de puente hacia el exterior:

class Ejemplo:

__atributo_privado = “Soy un atributo inalcanzable desde fuera”

def __metodo_privado(self):

print(“Soy un método inalcanzable desde fuera”)

def __metodo_privado(self):

print(“Soy un método inalcanzable desde fuera”)

def atributo_publico(self):

return self.__atributo_privado

def metodo_publico(self):

return self.__metodo_privado()

e = Ejemplo()

e.metodo_publico()

‘Soy un método inalcanzable desde fuera’

 

Autor entrada: CharlieJ

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *