Guia Python: métodos constructores de una clase.

Python es un lenguaje de script desarrollado por Guido van Rossum.
Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad)
Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)
Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.
El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).
Métodos de una clase.

Los métodos son como las funciones en los lenguajes estructurados, pero están definidos dentro de una clase y operan sobre los atributos de dicha clase.
Los métodos también son llamados las responsabilidades de la clase. Para encontrar las responsabilidades de una clase hay que preguntarse qué puede hacer la clase.
El objetivo de un método es ejecutar las actividades que tiene encomendada la clase a la cual pertenece.
Los atributos de un objeto se modifican mediante llamadas a sus métodos.
Confeccionaremos un nuevo problema para concentrarnos en la definición y llamada a métodos.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un título, indicarle si queremos que aparezca centrado, a derecha o izquierda.
Definiremos dos atributos, uno donde almacenar el título y otro donde almacenar la ubicación.
Ahora pensemos que métodos o responsabilidades debe tener esta clase para poder mostrar la cabecera de la página. Seguramente deberá tener un método que pueda inicializar los atributos y otro método que muestre la cabecera dentro de la página.
Veamos el código de la clase CabeceraPagina
class CabeceraPagina:
   def inicializar(self,tit,ubi):
   self.titulo=tit
   self.ubicacion=ubi

   def graficar(self):
   print '<div style="font-size:40px;text-align:'+self.ubicacion+'">'
   print self.titulo
   print '</div>'


cabecera=CabeceraPagina()
cabecera.inicializar('El blog del programador','center')
cabecera.graficar() La clase CabeceraPagina tiene dos atributos donde almacenamos el texto que debe mostrar y la ubicación del mismo ('center', 'left' o 'right'), nos valemos de CSS para ubicar el texto en la página.
No es obligatorio en Python definir previo a los métodos todos los atributos. Como vemos se definen e inicializan al llamar al método inicializar.
Ahora analicemos lo que más nos importa en el concepto que estamos concentrados (métodos de una clase):
def inicializar(self,tit,ubi):
   self.titulo=tit
   self.ubicacion=ubi Un método tiene un nombre, conviene utilizar verbos para la definición de métodos (mostrar, inicializar, graficar etc.) y sustantivos para la definición de atributos (color, enlace, titulo etc.)
Un método debe tener como primer parámetro el identificador self, el mismo nos permite acceder a los atributos de la clase, además puede tener otros parámetros que inicializan atributos del objeto:self.titulo=tit
   self.ubicacion=ubi Luego para llamar a los métodos debemos crear un objeto de dicha clase:
cabecera=CabeceraPagina()
cabecera.inicializar('El blog del programador','center')
cabecera.graficar() Es importante notar que siempre que llamamos a un método le antecedemos el nombre del objeto. El orden de llamada a los métodos es importante, no va a funcionar si primero llamamos a graficar y luego llamamos al método inicializar.
Método constructor de una clase.
El constructor es un método especial de una clase. El objetivo fundamental del constructor es inicializar los atributos del objeto que creamos.
Básicamente el constructor remplaza al método inicializar que habíamos hecho en el concepto anterior.
Las ventajas de implementar un constructor en lugar del método inicializar son:

1. El constructor es el primer método que se ejecuta cuando se crea un objeto.
2. El constructor se llama automáticamente. Es decir es imposible de olvidarse de llamarlo ya que se llamará automáticamente.
3. Quien utiliza POO (Programación Orientada a Objetos) conoce el objetivo de este método.

Otras características de los constructores son:

• El constructor se ejecuta inmediatamente luego de crear un objeto y no puede ser llamado nuevamente.
• Un constructor no puede retornar dato.
• Un constructor puede recibir parámetros que se utilizan normalmente para inicializar atributos.
• El constructor es un método opcional, de todos modos es muy común definirlo.

Veamos la sintaxis del constructor:
def __init__([parámetros]):
   [algoritmo] Debemos definir un método llamado __init__ (es decir utilizamos dos caracteres de subrayado, la palabra init y seguidamente otros dos caracteres de subrayado).
Confeccionaremos el mismo problema del concepto anterior para ver el cambio que debemos hacer de ahora en más.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un título, indicarle si queremos que aparezca centrado, a derecha o izquierda.
class CabeceraPagina:
   def __init__(self,tit,ubi):
   self.titulo=tit
   self.ubicacion=ubi

   def graficar(self):
   print '<div style="font-size:40px;text-align:'+self.ubicacion+'">'
   print self.titulo
   print '</div>'


cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar() Ahora podemos ver como cambió la sintaxis para la definición del constructor:
def __init__(self,tit,ubi):
   self.titulo=tit
   self.ubicacion=ubi Veamos como se modifica la llamada al constructor cuando se crea un objeto:
cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar() Es decir el constructor se llama en la misma línea donde creamos el objeto, por eso disponemos después del nombre de la clase los parámetros:
cabecera=CabeceraPagina('El blog del programador','center') Generalmente todo aquello que es de vital importancia para el funcionamiento inicial del objeto se lo pasamos mediante el constructor.
Llamada de métodos dentro de la clase.
Hasta ahora todos los problemas planteados hemos llamado a los métodos desde donde definimos un objeto de dicha clase, por ejemplo:
cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar() Utilizamos la sintaxis:
[nombre del objeto].[nombre del método] Es decir antecedemos al nombre del método el nombre del objeto y el operador punto
Ahora bien que pasa si queremos llamar dentro de la clase a otro método que pertenece a la misma clase, la sintaxis es la siguiente:
self.[nombre del método] Es importante tener en cuenta que esto solo se puede hacer cuando estamos dentro de la misma clase.
Confeccionaremos un problema que haga llamadas entre métodos de la misma clase.
Problema:Confeccionar una clase Tabla que permita indicarle en el constructor la cantidad de filas y columnas. Definir otra responsabilidad que podamos cargar un dato en una determinada fila y columna. Finalmente debe mostrar los datos en una tabla HTML.
class Tabla:
   mat=[]
   cantfilas=0
   cantcolumnas=0

   def __init__(self,fi,co):
   self.cantfilas=fi
   self.cantcolumnas=co
   for f in range(0,fi):
   self.mat.append([])
   for c in range(0,co):
   self.mat[f].append('')

   def cargar(self,fi,col,valor):
   self.mat[fi][col]=valor

   def iniciotabla(self):
   print '<table border="1">'
  
   def iniciofila(self):
   print '<tr>'

   def mostrar(self,fi,co):
   print '<td>'
   print self.mat[fi][co]
   print '</td>'

   def finfila(self):
   print '</tr>'

   def fintabla(self):
   print '</table>'

   def graficar(self):
   self.iniciotabla()
   for f in range(0,self.cantfilas):
   self.iniciofila()
   for c in range(0,self.cantcolumnas):
   self.mostrar(f,c)
   self.finfila()
   self.fintabla()
  
tabla1=Tabla(3,4)
tabla1.cargar(0,0,1)
tabla1.cargar(0,1,2)
tabla1.cargar(0,2,3)
tabla1.cargar(0,3,4)
tabla1.cargar(1,0,5)
tabla1.cargar(1,1,6)
tabla1.cargar(1,2,7)
tabla1.cargar(1,3,8)
tabla1.cargar(2,0,9)
tabla1.cargar(2,1,10)
tabla1.cargar(2,2,11)
tabla1.cargar(2,3,12)
tabla1.graficar() Vamos por parte, primero veamos los tres atributos definidos,el primero se trata de una lista donde almacenaremos todos los valores que contendrá la tabla HTML y otros dos atributos que indican la dimensión de la tabla HTML (cantidad de filas y columnas):
mat=[]
  cantfilas=0
  cantcolumnas=0 El constructor recibe como parámetros la cantidad de filas y columnas que tendrá la tabla, además creamos la lista con tantas filas como indica el parámetro fi e insertamos una lista en cada componente (es decir que cada componente de la lista es una lista que representa los elementos de la fila respectiva) Dentro de un for interno agregamos string vacíos a cada elemento de la lista interna:
self.cantfilas=fi
   self.cantcolumnas=co
   for f in range(0,fi):
   self.mat.append([])
   for c in range(0,co):
   self.mat[f].append('') Otro método de vital importancia es el de cargar datos. Llegan como parámetro la fila, columna y dato a almacenar:
def cargar(self,fi,col,valor):
   self.mat[fi][col]=valor Otro método muy importante es el graficar:
def graficar(self):
   self.iniciotabla()
   for f in range(0,self.cantfilas):
   self.iniciofila()
   for c in range(0,self.cantcolumnas):
   self.mostrar(f,c)
   self.finfila()
   self.fintabla() El método graficar debe hacer las salidas de datos dentro de una tabla HTML. Para simplificar el algoritmo definimos otros cinco métodos que tienen por objetivo hacer la generación del código HTML propiamente dicho. Así tenemos el método iniciotabla que hace la salida de la marca table e inicialización del atributo border:
def iniciotabla(self):
   print '<table border="1">' De forma similar los otros métodos son:
def iniciofila(self):
   print '<tr>'

   def mostrar(self,fi,co):
   print '<td>'
   print self.mat[fi][co]
   print '</td>'

   def finfila(self):
   print '</tr>'

   def fintabla(self):
   print '</table>' Si bien podíamos hacer todo esto en el método graficar y no hacer estos cinco métodos, la simplicidad del código aumenta a medida que subdividimos los algoritmos. Esto es de fundamental importancia con algoritmos más complejos./p>
Lo que nos importa ahora ver es como llamamos a métodos que pertenecen a la misma clase:
def graficar(self):
   self.iniciotabla()
   for f in range(0,self.cantfilas):
   self.iniciofila()
   for c in range(0,self.cantcolumnas):
   self.mostrar(f,c)
   self.finfila()
   self.fintabla() Es decir le antecedemos la palabra self al nombre del método a llamar. De forma similar a como accedemos a los atributos de la clase.
Por último debemos definir un objeto de la clase Tabla y llamar a los métodos respectivos:
tabla1=Tabla(3,4)
tabla1.cargar(0,0,1)
tabla1.cargar(0,1,2)
tabla1.cargar(0,2,3)
tabla1.cargar(0,3,4)
tabla1.cargar(1,0,5)
tabla1.cargar(1,1,6)
tabla1.cargar(1,2,7)
tabla1.cargar(1,3,8)
tabla1.cargar(2,0,9)
tabla1.cargar(2,1,10)
tabla1.cargar(2,2,11)
tabla1.cargar(2,3,12)
tabla1.graficar() Es importante notar que donde definimos un objeto de la clase Tabla no llamamos a los métodos iniciotabla(), iniciofila(), etc.