PDF de programación - Introducción a la programación orientada a objetos con Python

Introducción
a
la
programación
orientada
a
objetos


con
Python



































Notas
acerca
de
este
artículo


Este
artículo
ha
sido
extraído
de
la
página
web
http://blog.rvburke.com
cumpliendo
con
la
norma
de
copyright


establecida.


Copyright
©
Rafael
Villar
Burke,
2006.
Se
permite
la
distribución,
copia
y
modificación
de
los
textos,


siempre
y
cuando
se
indiquen
los
cambios
realizados,
se
conserve
el
copyright
y
esta
nota.


Su
autor
original
es
Rafael
Villar
Burke
y
el
artículo
data
del
22
de
Noviembre
de
2006.
La
versión
en
PDF
ha
sido


realizada
por
Oscar
Carballal
Prego
y
data
del
24
de
Noviembre
de
2009.


Se
ha
procedido
a
hacer
algunas
concesiones
visuales
de
cara
a
orientar
al
lector
de
forma
más
intuitiva
a
lo
que


está
viendo
en
cada
momento.
Los
textos
contenidos
en
cajas
grises
se
refieren
a
líneas
de
código,
y
los
textos


contenidos
en
cajas
con
borde
negro
son
las
representaciones
de
los
datos
que
deberían
salir
por
pantalla.
Esto


se
junta
con
las
concesiones
ya
establecidas
en
el
artículo
original,
las
cuales
son
mostradas
más
abajo.


“I
code,
therefore
I
am.”
































Este
artículo
es
una
introducción
a
la
programación
orientada
a
objetos
(POO,
o
OOP
por
sus
siglas
en
inglés),


uno
de
los
paradigmas
de
programación
estructurada
más
importante
hoy
en
día.


El
artículo
usa
el
lenguaje
Python
para
los
distintos
ejemplos,
y
explica
la
implementación
de
la
POO
en
ese


lenguaje,
aunque
aborda
conceptos
generales
que
son
fácilmente
trasladables
a
otros
lenguajes.


Los
fragmentos
de
código
se
señalan
usando
un
estilo
de
texto
diferente
(ancho
fijo)
y,
cuando
se
utiliza
el


intérprete
de
python,
se
prefija
cada
línea
con
los
símbolos
‘>>>’.
Esta
introducción
presupone
conocimientos


básicos
de
programación
y
del
lenguaje
python.


Formas
de
pensar:
paradigmas
de
programación


Uno
de
los
elementos
básicos
a
la
hora
de
realizar
un
programa
es
la
modelización
del
problema
que
pretende


resolver.
Es
preciso
localizar
las
variables
y
los
aspectos
relevantes,
así
como
comprender
los
pasos
necesarios


para
obtener
el
resultado
a
partir
de
los
datos
iniciales,
etc.
Es
decir,
abstraer
el
problema,
reduciendo
sus


detalles
de
forma
que
podamos
trabajar
con
pocos
elementos
cada
vez.


La
algoritmia
plantea
la
forma
óptima
de
resolver
problemas
concretos,
tales
como
la
ordenación
de
una
lista
de


elementos,
la
búsqueda
de
un
elemento
en
un
conjunto,
la
manipulación
de
conjuntos
de
datos,
etc.
Sin


embargo,
no
proporcionan
un
marco
general,
un
enfoque,
que
nos
permita
plantear
y
formular
las
soluciones
a


un
problema
de
forma
coherente.


Los
paradigmas
de
programación
llenan
ese
hueco,
proporcionando
guías
tanto
sobre
cómo
realizar
la


abstracción
de
los
datos
como
sobre
el
control
de
la
ejecución.
Es
decir,
los
paradigmas
de
programación
son


herramientas
conceptuales
para
analizar,
representar
y
abordar
los
problemas,
presentando


sistematizaciones
alternativas
o
complementarias
para
pasar
del
espacio
de
los
problemas
al
de
las


implementaciones
de
una
solución.


Es
muy
recomendable
y
productivo
comprender
el
enfoque
de
distintos
paradigmas,
puesto
que
presentan


estrategias
alternativas,
incrementando
nuestras
herramientas
disponibles
y
haciéndono
reflexionar
sobre


muchas
de
las
tareas
que
realizamos
al
crear
un
programa.
Además,
a
menudo
ocurre
que
unos
problemas
se


formulan
de
forma
muy
clara
si
se
los
analiza
según
una
perspectiva
determinada,
mientras
que
producen
una


gran
complejidad
vistos
de
otra
manera.


Algunos
paradigmas
habituales


Algunas
de
las
formas
de
pensar
los
problemas
que
ha
llegado
a
sistematizarse
como
paradigmas
de


programación
son:


La
programación
modular:
Los
programas
se
forman
por
partes
separadas
llamadas
módulos.
Estos


funcionan
de
forma
independiente
entre
sí,
o
se
relacionan
a
través
de
interfaces
bien
definidas.


 La
programación
procedural:
Un
programa
se
compone
de
procedimientos
(subrutinas,
métodos
o


funciones)
que
son
fragmentos
de
código
que
pueden
llamarse
desde
cualquier
punto
de
la
ejecución


de
un
programa,
incluídos
otros
procedimientos
o
él
mismo.
(ej.
ALGOL)


La
programación
estructurada:
Se
puede
expresar
cualquier
programa
utilizando
únicamente
tres


estructuras
de
control:
secuencial,
condicional
e
iterativa.
Los
programas
se
componen
de
partes


menores
con
un
único
punto
de
entrada,
y
se
trata
de
aislarlos
para
evitar
la
complejidad
que


introducen
los
efectos
colaterales.
(ej.
Pascal,
C,
Ada)


La
programación
imperativa:
Un
programa
se
puede
definir
en
términos
de
estado,
y
de
instrucciones


secuenciales
que
modifican
dicho
estado.
(ej.
C,
BASIC)


La
programación
declarativa:
Es
posible
expresar
un
programa
a
través
de
condiciones,
proposiciones
o


restricciones,
a
partir
de
los
que
se
obtiene
la
solución
mediante
reglas
internas
de
control.
(ej.


PROLOG)


La
programación
funcional:
Se
puede
expresar
un
programa
como
una
secuencia
de
aplicación
de
funciones.


Elude
el
concepto
de
estado
del
cómputo
y
no
precisa
de
las
estructuras
de
control
de
la
programación


estructurada.
(ej.
LISP,
Haskell)


La
programación
orientada
a
objetos:
Los
programas
se
definen
en
términos
de
“clases
de
objetos”
que
se


comunican
entre
sí
mediante
el
envío
de
mensajes.
Es
una
evolución
de
los
paradigmas
de
la


programación
procedural,
estructurada
y
modular,
y
se
implementa
en
lenguajes
como
Java,


Smalltalk,
Python
o
C++.





Programación
multiparadigma


Los
paradigmas
de
programación
son
idealizaciones,
y,
como
tales,
no
siempre
se
presentan
de
forma


totalmente
‘pura’,
ni
siempre
resultan
incompatibles
entre
sí.
Cuando
se
entremezclan
diversos
paradigmas
se


produce
lo
que
se
conoce
como
programación
multiparadigma.


El
uso
de
distintos
modelos,
según
se
adapten
mejor
a
las
diversas
partes
de
un
problema
o
a
nuestra
forma
de


pensamiento,
resulta
también
más
natural
y
permite
expresar
de
forma
más
clara
y
concisa
nuestras
ideas.


Algunos
lenguajes,
como
Haskell
o
Prolog
están
diseñados
para
encajar
perfectamente
en
la
visión
de
un


paradigma
particular,
mientras
que
otros,
como
python,
se
adaptan
especialmente
bien
a
la
programación


multiparadigma
y
dan
gran
libertad
a
la
hora
de
resolver
un
problema,
al
no
imponen
un
mismo
patrón
para


todos
los
casos.


Tipos
de
datos


Una
forma
de
almacenar
y
representar
una
fecha
en
un
programa
podría
ser
la
siguiente:


d = 14
m = "Noviembre"

a = 2006
def dime_fecha(dia, mes, anho):
return "%i de %s de %i del calendario gregoriano" % (dia, mes, anho)
print fecha(d, m, a)

para
obtener
la
siguiente
salida:


"14
de
Noviembre
de
2006"


En
este
ejemplo,
para
representar
y
manipular
lo
que
conceptualmente
entendemos
como
una
fecha,
se
utilizan

las
variables
d,
m
y
a
como
almacenes
de
datos,
y
un
procedimiento
o
función,
de
nombre
dime_fecha,
para

realizar
la
representación
de
la
fecha
almacenada.


Las
variables
permiten
almacenar
tipos
de
datos
concretos
como
los
enteros
(d
y
a)
o
las
cadenas
de
texto
(m),
y

la
función
realiza
su
trabajo
devolviendo
otro
tipo
concreto,
una
cadena
de
texto.


Uno
de
los
problemas
de
este
enfoque
es
que
no
refleja
demasiado
bien
el
concepto
fecha
que
usamos
como

modelo
mental
al
implementarlo
como
un
conjunto
de
tres
variables
no
relacionadas
entre
sí
(d,
m
y
a).
Es
decir,

las
tres
variables
tienen
una
unidad
conceptual
en
nuestra
mente,
que
no
se
refleja
en
la
forma
de
expresar
el

problema.
De
la
misma
manera,
la
función
dime_fecha
desconoce
igualmente
la
relación
entre
sus
parámetros,

que
podría
ser
totalmente
arbitraria.


Esta
situación,
que
puede
parecer
una
cuestión
de
‘estilo’,
implica
un
riesgo
de
problemas
de
sincronización

entre
variables
‘relacionadas’,
dispersión
en
distintas
partes
del
código
de
manipulaciones
que
son
relevantes
al

conjunto,
pérdida
del
valor
semántico
de
cada
variable
que
puede
dar
lugar
a
errores
al
transformar
el
código…


Un
ejemplo
de
desconexión
semántica
entre
la
implementación
y
el
concepto
es
que
d
puede
ser
cualquier
valor

entero,
mientras
que
un
día
tiene
un
valor
situado
entre
1
y
31,
m
es
una
cadena
de
texto
dentro
de
un
número

limitado
de
opciones,
o
a
no
puede
tomar
valores
negativos.
Por
supuesto
que
esto
se
podría
solucionar
con

código
que
hiciese
comprobaciones
adicionales,
pero
en
este
caso
queremos
resaltar
cómo
un
programa
es
un

modelo
aproximado
a
un
problema
y
cómo
sería
preferible
que
la
implementación
pudiese
representar
de
forma

más
ajustada
el
comportamiento
del
modelo
elegido.


Una
posible
solución
sería
disponer
de
un
tipo
de
datos
que
represente
de
forma
más
adecuada
el
concepto
de

fecha
y
que
nos
permita
manipular
fechas
de
la
misma
manera
que
manipulamos
números
enteros,
números

reales
o
cadenas
de
texto,
independientemente
de
la
implementación
interna
que
los
sustente.


Clases
y
objetos


Al
enunciar
algunos
tipos
de
paradigmas
hemos
visto
que
la
programación
orientada
a
objetos
define
los


programas
en
términos
de
“clases
de
objetos”
que
se
comunican
entre
sí
mediante
el
envío
de
mensajes.
En


este
apartado
aclararemos
qué
se
entiende
en
ese
contexto
por
clases
y
objetos.


Las
clases
surgen
de
la
generalización
de
los
tipos
de
datos
y
permiten
una
representación
más
directa
de
los


conceptos
necesarios
para
la
modelización
de
un
problema
permitiendo
definir
nuevos
tipos
al
usuario.


Las
clases
permiten
agrupar
en
un
nuevo
tipo
los
datos
y
las
funcionalidades
asociadas
a
dichos
datos,


favoreciendo
la
separación
entre
los
detalles
de
la
implementación
de
las
propiedades
esenciales
para
su
uso.
A


esta
cualidad,
de
no
mostrar
más
que
la
información
relevante,
ocultando
el
estado
y
los
métodos
internos
de
la


clase,
es
conocida
como
“encapsulación”,
y
es
un
principio
heredado
de
la
programación
modular.


Un
aspecto
importante
en
el
uso
de
clases
es
que
no
se
manipulan
directamente
(salvo
en
lo
que
se
conoce


como
metaprogramación),
sino
que
sirven
para
la
definición
nuevo