Programación orientada a objetos en Python.

Python es un lenguaje #multiparadigma y esto puede hacer que aprender el lenguaje sea complicado, sobre todo para mí que estoy acostumbrado a C# que es un lenguaje orientado a objetos estricto, pasar a un lenguaje tan libre, termina por abrumarme.

Esta vez trataré de aplicar el paradigma orientado a objetos en #Python. Los siguientes ejemplos son tomados de w3Schools.com para que los tome de referencia, aquí solo me centraré en dar mi interpretación.

Accesibilidad de las variables.

• Python es un lenguaje muy versátil, pero a veces siento que es un lenguaje muy poco seguro, ya que las variables por defecto son públicas y son accesibles desde otros módulos, pero si al nombre de la variable le antecedes dos guión bajo ``__variable_name``, esto lo hace inaccesible fuera del módulo.

• Con anteceder un guión bajo al nombre de la variable ``_variable_name``, aún sigue siendo pública, pero el IDE lo oculta de las sugerencias de código.

• Otra forma de volver privada una variable es meterla dentro de una función y recordemos que Python es un lenguaje multiparadigma y esto incluye al paradigma funcional, si las variables las usas dentro de la función ``def main():``, esta no podrá ser accesible fuera de esta.

accesible = "Esta variable es accesible y global"

def main():
    inaccesible = "Esta variable no es accesible"
    global variable_global
    variable_global = "Esta variable es accesible fuera de la función"

if __name__ == "__main__":
    main()

• Una manera de volver accesible una variable dentro de una función, es declarándola con la palabra global antes del nombre de la variable, pero sin asignar ningún valor.

Pero a pesar de que parezca que es privado, nunca es privado, Python no fue diseñado con eso en mente, aunque los #pythonistas dice que las variables, clases y métodos privados son una ridiculez, para un simple mortal pienso que es una ridiculez, pero para una empresa que necesita proteger su código del hackeo, si es necesario la privacidad.

En el futuro hablaremos de este tema de la privacidad, ya que hay mucha tela que cortar y mucho debate al respecto. Lo cierto es que nada es privado en Python y por tanto tampoco hay encapsulamiento de atributos, no hay ni get ni set.

¿Como hacer un módulo?

Simplemente escribe tu código y guárdalo con el nombre que quieras con la extensión *.py, dentro de la misma carpeta del proyecto. Ejemplo:

``miModulo.py``

Para usarlo simplemente usa la palabra reservada ``import``.

import miModulo

¿Como hacer una clase?

Solo basta con escribir la palabra reservada ``class`` y luego el nombre de la clase.

class myClass:
    x = 5

Las clases también pueden heredar de otras clases, suponiendo que miModulo.py tiene una clase que podamos usar, sería así:

class miClass(miModulo):
    x = 5

¿Como usar objetos?

Simplemente desde nuestro código podemos llamar a la clase de la siguiente forma.

mi_clase = myClass()

Como si se tratara de una función que retorna algo, lo que realmente está retornando es la clase en sí con todos sus propiedades y funciones. Luego es fácil acceder a sus propiedades así:

print(mi_clase.x) #Esto debe retornar el valor de 5

La función __init__()

• Todo lo anterior es una representación simple de como usar clases y objetos, pero no tiene ningún uso práctico en la vida real.

• Todas las clases tienen una función predefinida llamada ``__init__()``. En esta función podremos añadirle parámetros que nos permiten modificar las propiedades de la clase:

class myClass:
	def __init__(self,x,y):
		self.x = x
		self.y = y

mi_clase = myClass(5,10)
print(mi_clase.y)

Métodos de los objetos.

El nombre de Método, solo se refiere a una función dentro de una clase, pero no es distinto de una función común y silvestre.

class myClass:
	def __init__(self,x,y,name):
		self.x = x
		self.y = y
		self.name = name
	def myFunction(self):
		print("my name is:", self.name)

mi_clase = myClass(5,10,"John")
mi_clase.myFunction()

El parámetro self.

• El parámetro ``self`` hace referencia a la instancia actual de la misma clase y es usado para acceder a las variables dentro de la misma clase.

• Este no es necesariamente obligatorio ser llamado ``self``, este puede ser nombrado como quiera, pero es obligatorio que sea el primer parámetro dentro de cada función.

class myClass:
    def __init__(mySillyObject,x,y,name):
        mySillyObject.x = x
        mySillyObject.y = y
        mySillyObject.name = name
    def myFunction(abc):
        print("my name is:", abc.name)

mi_clase = myClass(5,10,"John")
mi_clase.myFunction()

Modificando las propiedades de los objetos.

En todos estos ejemplos el valor de la variable x dentro del objeto es 5, para modificarlo simplemente cambia el valor desde el objeto.

mi_clase = myClass(5,10,"John")
mi_clase.x = 15

Eliminando propiedades de los objetos.

Para eliminar propiedades, se puede hacer mediante la palabra reservada ``del``, esto es algo curioso, nunca en mi vida había visto que se pudiera eliminar propiedades y objetos.

del mi_clase.x # Elimina la propiedad x del objeto mi_clase.

Eliminando objetos.

Se puede eliminar objetos usando la palabra reservada ``del``:

del mi_clase

El uso de la declaración pass.

Al igual que en las funciones hacemos uso de la declaración ``pass`` para crear una función vacía, también podemos hacer uso de la declaración ``pass`` para crear clases vacías.

Clases abstractas.

Una clase abstracta tiene funciones que no tienen una implementación, pero que la clase que herede de esta, está obligado a usar cada una de las funciones mencionadas dentro de la clase abstracta. El siguiente es un ejemplo que estoy usando para un proyecto en Pygame.

class Scene:
    """Representa una escena abstracta del videojuego.

    Una escena es una parte visible del juego, como una pantalla
    de presentación o menú de opciones. Tiene que crear un objeto
    derivado de esta clase para crear una escena utilizable."""

    def __init__(self, director):
        self.director = director

    def on_update(self):
        "Actualización lógica que se llama automáticamente desde el director."
        raise NotImplemented("Tiene que implementar el método on_update.")

    def on_event(self, event):
        "Se llama cuando llega un evento específico al bucle."
        raise NotImplemented("Tiene que implementar el método on_event.")

    def on_draw(self, screen):
        "Se llama cuando se quiere dibujar la pantalla."
        raise NotImplemented("Tiene que implementar el método on_draw.")

A continuación la implementación de la clase abstracta.

class SceneHome(scene.Scene):
	"""Escena inicial del juego, esta es la primera que se carga cuando inicia"""
    
	def __init__(self, director):
		scene.Scene.__init__(self, director)
       
	def on_update(self):
		pass

	def on_event(self):
		for event in pygame.event.get():
			if event.type == pygame.KEYDOWN:
				
				.........		

	def on_draw(self, screen):
		screen.fill("white")
		event_text(screen, str("Hola mundo"), [255,255,255], cfg.ParagraphFont)
		
				........

Conclusiones.

Python puede volarle la cabeza a quien viene de lenguajes como Java o C#, donde existe la privacidad, en Python todo es público, lo que te hace preguntar si un hacker puede ver esto como una vulnerabilidad y usarlo a su favor.

Python tiene una filosofía de confiar en lo que hace el programador y en tratarlos como personas adultas, en mi experiencia, la gente por muy adulta que sea no deja de actuar como imbéciles y si estoy a favor de la privacidad en las variables y los métodos, pero también los sistemas informáticos tienen fallos y eso no impide que un hacker pueda igualmente acceder, así que también les doy la razón a los pythonistas, pero no por eso voy a dejar la puerta abierta de mi casa cuando estoy durmiendo.

Por otro lado, la orientación a objetos aplicada en Python es muy simple y fácil de implementar y de entender, porque se quita de encima un montón restricciones, sellos y pendejadas que lo único que hacen es complicar las cosas.

Para simples mortales como nosotros que hacemos programas pequeños, un lenguaje sencillo de aprender nos basta y nos sobra, ahora si deseas ser estricto con el paradigma orientado a objetos y necesitas un programa que escale bien con el tiempo, para eso esta C# y Java.

Eso es todo por ahora, espero que este blog ayude a resolver dudas, pronto haré uno que explique mas a fondo la privacidad de las variables en Python.