Python viene con multitud de tipos de datos integrados como, dict, list, set... ¿Alguna vez has pensado si puedes crear tus propios tipos de datos? Como una persona, un coche, universidades, etc. Sería útil crear estos tipos de datos también para nuestros desarrollos, ¿verdad? Pues con Python es posible, y es donde entrar en juego las clases y los objetos.
Clases
Como he mencionado anteriormente, las clases y los objetos sirven para crear tu propio tipo de datos (es decir, tipos de datos definidos por el usuario). Una clase es un tipo de dato definido por el usuario, y la crear instancias de una clase hace relación a la creación de objetos de ese tipo. Las clases y los objetos son considerados los principales bloques de desarrollo para Python, el cual es un lenguaje de programación orientado a objetos.
Cómo crearíamos una clase en Python? La estructura de clase más simple en Python luciría de la siguiente manera:
class ClassName:
statements
Como puedes ver, la definición de una clase comienza con la palabra clave class, y className sería el nombre de la clase (identificador). Ten en cuenta que el nombre de la clase sigue las mismas reglas que los nombres de variables en Python, es decir, sólo pueden comenzar con una letra o un subrayado _, y sólo pueden contener letras, números o guiones bajos. Además, según PEP 8 (Guía de estilo para la programación en Python), se recomienda que los nombres de las clases estén capitalizadas.
Ahora vamos a definir una clase Person (persona), que por el momento no contendrá nada, excepto la declaración de pass. Según la documentación de Python:
La sentencia pass no hace nada. Puede ser utilizada cuando se requiere una sentencia sintácticamente pero programa no requiere acción alguna.
class Person:
pass
Para crear una instancia (objeto) de esta clase, simplemente haremos lo siguiente: jorge = Person()
Esto significa que hemos creado un nuevo objeto jorge del tipo Person. Date cuenta que para crear un objeto solo debemos escribir el nombre de la clase, seguido de unos paréntesis.
Podemos identificar de qué clase es jorge, y qué espacio ocupa en la memoria escribiendo: print jorge. En ese caso, obtendrás algo similar a:
< __main__.Person instance at 0x109a1cb48 >
Atributos
Los atributos son como propiedades que queremos añadir a la clase (tipo). Por ejemplo, para nuestra clase Person, vamos a añadir dos atributos: name y school, tal que así:
class Person:
name = ''
school = ''
Ahora, vamos a crear un nuevo objeto del tipo Person con más detalle, completando estos atributos que acabamos de añadir:
jorge = Person()
abder.name = 'Jorge'
abder.school = 'Universidad de la vida'
Métodos
Los métodos son cómo funciones en Python, ya que se definen con la palabra clave def y cuentan con el mismo formato que las funciones. En nuestra clase, vamos a definir un método que imprima el nombre (name) y la escuela (school) de una persona (Person). La clase se verá de la siguiente manera:
class Person:
name = ''
school = ''
def print_name(self):
print self.name
def print_school(self):
print self.school
jorge = Person()
jorge.name = 'Jorge'
jorge.school = 'Universidad de la vida'
jorge.print_name()
jorge.print_school()
He mencionado anteriormente que los métodos son como funciones. Sin embargo, la principal diferencia es que los métodos necesitan tener un argumento convenientemente llamado self, que se refiere al objeto del método que está siendo llamado (es decir jorge). Date cuenta que en una llamada al método, no necesitamos pasar self como un argumento, Python se encargará de eso por nosotros.
Si no ponemos self como argumento en print_name(), Python arrojará un error tal que así:
Traceback (most recent call last):
File "test.py", line 3, in < module >
print_name(employee_name)
NameError: name 'print_name' is not defined
Por lo que, para que no ocurra esto, procura llamar a la función, siempre después de haberlo declarado.
Vamos a ver otro ejemplo. En este ejemplo utilizaremos listas. Asumiendo que tenemos la siguiente lista:
numbers_list = [1,2,3,4,5]
Esta función servirá para insertar nuevos números en la lista que pasaremos a la función:
numbers_list = [1,2,3,4,5]
def insert_numbers(numbers_list):
numbers_list.insert(5, 8)
numbers_list.insert(6, 13)
print 'List "inside" the function is: ', numbers_list
return
insert_numbers(numbers_list)
print 'List "outside" the function is: ', numbers_list
La salida de esta función sería:
List "inside" the function is: [1, 2, 3, 4, 5, 8, 13]
List "outside" the function is: [1, 2, 3, 4, 5, 8, 13]
¿Qué podemos extraer de todo esto? Podemos concluir que los parámetros se pasan por referencia. Es decir, los parámetros de la llamada a la función son los mismos que los argumentos pasados (variable/identidad) por parte de la llamada, en lugar de pasarlos por valor, donde los llamados parámetros de la función son una copia de llamada.
Una sencilla calculadora
Vamos a usar nuestro conocimiento de las funciones para desarrollar una aplicación un poco más interesante. Vamos a desarrollar una calculadora sencilla. Esta calculadora permitirá al usuario introducir dos números, y realizar la suma, resta, multiplicación y división de los dos números.
def add(x,y):
return x+y
def subtract(x,y):
return x-y
def multiply(x,y):
return x*y
def divide(x,y):
return x/y
x = 8
y = 4
print '%d + %d = %d' % (x, y, add(x, y))
print '%d - %d = %d' % (x, y, subtract(x, y))
print '%d * %d = %d' % (x, y, multiply(x, y))
print '%d / %d = %d' % (x, y, divide(x, y))
Creo que con esto, debe haberte quedado más claro el funcionamiento de las funciones de Python.
Comments