Desde «hola mundo» a conexiones con Bases de datos

Clases

Objetos y Clases Las clases permiten que podamos definir nuestros propios tipos de datos Las Clases definen las propiedases (atributos) y las capacidades y comportamiento (métodos) general de los nuevos tipos Un objeto se crea o instancia a partir de una clase

Objetos Un objeto es una variable que representa un caso particular dentro del conjunto de posibles instancias de una clase De la misma forma que podemos considerar al número 7 como una instancia particular de la clase Numeros Enteros

Creación de clases Palabra reservada class La clase más sencilla que podemos pensar es: >>> class X: ... pass >>> Instanciamos un objeto usando el nombre de la clase como si fuera una función: >>> x = X() >>> print(x)

La clase Point Inicializador: Método con el nombre especial __init__ No es el constructor, pero casi class Point: def __init__(self, lat, lng): self.latitud = lat self.longitud = lng x = Point(28.4779, -16.3118) print(x.latitud, x.longitud)

¿self? Se crea el objeto. Inmediatamente a continuación, como hemos visto, se llama al inicializador los dos parámetros que usamos al crear al objeto son los mismos valores que se pasan al método inicializador con los nombres lat y lng Pero ¿De donde sale el primer parámetro, self? ¿Y qué representa?

Para programadores de C++ o Java Para programadores de C++ o Java es la variable "magica" this. En Python se prefirió esta forma por considerarla más explicita. De igual manera, los atributos dentro de la función tienen que venir precedidos por el self., no hay alias mágicos para los atributos de la instancia, para evitar la ambigüedad.

Seguimos con self Empezemos por la segunda pregunta: self representa al propio objeto recien creado Este primer parámetro es lo que diferencia a las funciones que ya conociamos de los métodos: un método siempre tienen como primer parámetro la instancia sobre la que está siendo ejecutado.

Quien pone self ahí Al definir métodos para una clase, hay que reservar el primer parámetro para el propio objeto Al llamar al método desde la instancia, Python ya se ocupa de poner el valor correcto como primer parámetro La tradición y la costumbre marcan que este primer parámetro se llame self, pero en realidad no existe obligación de hacerlo (pero es conveniente hacerlo, por legibilidad)

Herencia Para poder hablar de clases y objetos con propidad es necesario que haya algún tipo de herencia La herencia nos permite definir una clase a base de refinar o modificar otra (herencia simple) u otras (herencia múltiple)

Herencia simple Si una clase A deriva o hereda de una clase B (o también se dice que la clase B es una superclase de A): Entonces la clase A dispondrá, de entrada, de todos los atributos y métodos de B Pero puede añadir más atributos y métodos e incluso modificar o borrar los que ha heredado.

Como declarar herencia en Python La forma de expresar esta herencia en python es >>> class A(B): ... pass Si la clase modifique un método que ha heredado, se dice que ha reescrito o sobreescrito (override) el método.

Características de la herencia Como los objetos instanciados de A tienen los mismos atributos y métodos que B, deben poder ser ser usados en cualquier sitio donde se use una instacia de B Entre A y B hay una relación es un tipo de B es un caso general de A O,si se prefiere, A es una especializacion de B

Beneficios de usar clases/objetos Reducir el tamaño del código evitando repeticiones Si organizamos las herencias correctamente en jerarquias, de mas genéricas a más específicas, podemos compatibilizar el código común de las primeras con el más específico de las últimas Encapsulamiento Polimorfismo Delegación de responsabilidades

super ¿Que pasa si A sobreescribe un método de B, pero aun así ha de invocarlo? En realidad es un caso muy común, A quiere hacer lo mismo que B, y un poquito más. Desde Python 2.2 hay una función super() que nos ayuda a invocar el código de la clase (o clases) de la que derivamos. Python 2.x Python 3.x class A(B): def f(self, arg): super(A, self).f(arg) ... class A(B): def f(self, arg): super().f(arg)

Funciones auxiliares isinstance(objeto, clase) nos devolverá verdadero si el objeto es una instancia de una clase en particular, o de alguna de sus subclases issubclass(objeto, clase) nos devolverá verdadero si el objeto es una instancia de una subclase de la clase indicada.

Sobrecarga de operadores Se puede, como en C++, sobreescribir los operadores (operadores aritméticos, acceso por índices, etc...) mediante una sintaxis especial Los métodos y atributos que empiezan y acaban con un doble signo de subrayado tiene por lo general un significado especial.

Sobrecarga de operadores: len Si en nuestra clase definimos un método __len__(), podemos hacer que las instancias de esa clase puedan ser usadas con la función len() Véase ejemplos/clases_02.py

Sobrecarga de operadores: índices Si a una clase le añadimos los métodos __setitem__ y __getitem__ podemos hacer que se comporte como si fuera una contenedor accesible mediante las operaciones de índices

def __getitem__(self, index): if 0 <= index < 7: Ejemplos/clases_03.py class A: _Tabla = { 0: 'ninguno', 1: 'uno', 2: 'dos', 3: 'tres', 4: 'cuatro', 5: 'cinco', 6: 'umm... seis', } def __len__(self): return 7 # por la cara def __getitem__(self, index): if 0 <= index < 7: return self._Tabla[index] else: return 'Muchos' def __setitem__(self, index, value): pass

Sobrecarga de operadores: +/- Supongamos que queremos escribir un módulo de álgebra lineal y que definimos la clase Vector Podríamos crear una función independiente para sumar vectores: v1 = Vector(2, 3) v2 = Vector(-4, 2) v3 = suma_vector(v1, v2) Pero es claramente mejor, más legible y bonito, poder hacer v3 = v1 + v2

def __init__(self, x, y): self.x = x self.y = y def __str__(self): ejemplos/clases_04.py class Vector: def __init__(self, x, y): self.x = x self.y = y def __str__(self): return 'Vector({}, {})'.format(self.x, self.y) def __add__(self, other): return Vector( self.x + other.x, self.y + other.y ) def __sub__(self, other): self.x - other.x, self.y - other.y

Sobrecarga de operadores: +/- Para eso definimos los métodos especiales __add__ y __sub__ para definir el comportamiento cuando se sumen o resten dos instancias de nuesta clase. Véase ejemplos/clases_04.py Existen muchos métodos especiales A Guide to Python's Magic Methods: http://www.rafekettler.com/magicmethods.html

Conexion y trabajo con Postgresql

Breve reseña sobre el Framework Django