INTRODUCCIÓN A
LA PROGRAMACIÓN
PYTHON
Lic. Rodman Cevallos
OBJETIVOS
• Programación orientada a objetos
• Estructuras de datos
Python 2
ÍNDICE
• Programación orientada a objetos
• Búsqueda y ordenación
• Estructuras de datos
Python 3
LIMITACIONES DE LA
PROGRAMACIÓN
ESTRUCTURADA
• La descomposición de programas en funciones no es suficiente
para conseguir la reusabilidad de código.
• Es difícil entender, mantener y actualizar un programa que
consiste de una gran colección de funciones.
• Con la programación orientada a objeto se supera las limitaciones
de la programación estructurada mediante un estilo de
programación en el que las tareas se resuelven mediante la
colaboración de objetos.
Python 4
PROGRAMACIÓN ORIENTADA A
OBJETOS (OOP) EN PYTHON
• Una clase es una plantilla de entidades del mismo tipo. Una
instancia es una realización particular de una clase. Python
soporta instancias de clases y objetos.
• Un objeto contiene atributos: atributos de datos (o variables)
y comportamiento (llamados métodos). Para acceder un
atributo se usa el operador punto, ejemplo:
nombre_instancia.nombre_atributo
• Para crear una instancia de una clase se invoca el constructor:
nombre_instancia = nombre_clase(args)
Python 5
OBJETOS DE CLASE VS OBJETOS DE
INSTANCIA
• Los objetos de clase sirven como factorías para generar
objetos de instancia. Los objetos instanciados son objetos
reales creados por una aplicación. Tienen su propio
espacio de nombres.
• La instrucción class crea un objeto de clase con el nombre
de clase. Dentro de la definición de la clase se puede crear
variables de clase y métodos mediante def que serán
compartidos por todas las instancias
Python 6
CLASES – REPRESENTACIÓN UML
Python 7
SINTAXIS DE LA DEFINICIÓN DE
CLASE
• La sintaxis es:
class Class_name(superclass1, ...):
"""Class doc-string"""
class_var1 = value1 #
Class variables
......
def init (self, arg1, ...):
"""Constructor"""
self.instance_var1 = arg1 # inst var by assignment
......
def str (self):
"""For printf() and str()"""
......
def repr (self):
"""For repr() and interactive prompt"""
......
def method_name(self, *args, **kwargs):
Python """Method doc-string""" 8
......
CONTRUCTORES
• Un constructor es un método que inicializa las
variables de instancia de un objeto
– Se invoca automáticamente cuando se crea un
objeto.
Crea una instancia
register = CashRegister() de CashRegister
• Python usa el nombre especial _ _init_ _ para
el constructor porque el propósito es inicializar una
instancia de la clase.
Python 9
CONTRUCTOR:
SELF
• El primer parámetro de un constructor debe ser self
• Cuando se invoca el constructor para crear un nuevo objeto, el
parámetro self se asigna al objeto que esta siendo
inicializado
Referencia al
def _ _init_ _(self) objeto inicializado
self._itemCount = 0
self._totalPrice = 0
Crea una instancia
register = CashRegister() de CashRegister
Referencia al objeto creado cuando
Python el contructor termina 10
EJEMPLO – CIRCLE.PY
Python 11
EJEMPLO –
CIRCLE.PY
• circle.py:
from math import pi
class Circle:
"""A Circle instance models a circle with a radius""" def
init (self, radius=1.0):
"""Constructor with default radius of 1.0""" self.radius =
radius # Create an inst var
radius
def str (self):
"""Return string, invoked by print() and str()""" return
'circle with radius of %.2f' % self.radius
def repr (self):
"""Return string used to re-create this instance""" return
'Circle(radius=%f)' % self.radius
def get_area(self):
"""Return the area of this Circle instance""" return
Python 12
self.radius * self.radius * pi
EJEMPLO –
CIRCLE.PY
• circle.py (cont.):
# if run under Python interpreter, name is '__main '.
# if imported into another module, name is 'Circle'
if name == ' main ':
c1 = Circle(2.1) # Construct an instance
print(c1) # Invoke str ()
print(c1.get_area())
c2 = Circle() # Default radius
print(c2)
print(c2.get_area()) # Invoke member method
c2.color = 'red' # Create new attribute via assignment
print(c2.color)
# Error - c1 has no attribute color
#print(c1.color)
# Test doc-strings
print( doc ) # This module
print(Circle. doc ) # Circle class
print(Circle.get_area. doc ) # get_area() method 13
print(isinstance(c1, Circle)) # True
Python
CONSTRUCCIÓN DE
CLASE
• Para construir una instancia de una clase se realiza a través del
constructor nombre_clase(…)
c1 = Circle(1.2)
c2 = Circle() # radius default
• Python crea un objeto Circle, luego invoca el método
_ _init_ _(self, radius) con self asignado a la nueva instancia
• _ _init_ _() es un inicializador para crear variables de instancia
• _ _init()_ _ nunca devuelve un valor
• _ _init()_ _ es opcional y se puede omitir si no hay variables
de instancia
Python 14
MÉTODOS DE
INSTANCIA
• Para invocar un método se usa el operador punto, en la forma
nombre_obj.nombremetodo ( ). Python diferencia entre instancias de
objetos y objetos de clase:
– Para objetos de clase: se puede invocar
class_name.method_name(instance_name, ...)
– Para instancia de objetos:
instance_name.method_name(...)
donde instance_name es pasado en el método como el
argumento 'self'
Python 15
LA REFERENCIA
SELF
• Cada método tiene una referencia al objeto sobre el
cual el método fue invocado, almacenado en la
variable parámetro self.
def addItem(self, price):
self._itemCount = self._itemCount + 1
self._totalPrice
Python
= self._totalPrice + 16
price
CLASE POINT Y SOBRECARGA DE
OPERADORES
• Ejemplo: point.py que modela un punto 2D con coordenadas x e y.
Se sobrecarga los operadores + y *:
Python 17
CLASE POINT Y SOBRECARGA
DE OPERADORES
• point.py modela un punto 2D con coordenadas x e y.
Se sobrecarga los operadores + y *:
""" point.py: point module defines the Point class"""
class Point:
"""A Point models a 2D point x and y
coordinates""" def init (self, x=0, y=0):
"""Constructor x and y with default of (0,0)"""
self.x = x
self.y = y
def str (self):
"""Return a descriptive string for this instance"""
return '(%.2f, %.2f)' % (self.x, self.y)
def add (self, right):
"""Override the '+' operator"""
p = Point(self.x + right.x, self.y
+ right.y) 18
Python
return p
CLASE POINT Y SOBRECARGA
DE OPERADORES
def
mul (self, factor):
"""Override the '*' operator"""
self.x *= factor
self.y *= factor
return self
# Test
if name == ' main
': p1 = Point()
print(p1) # (0.00, 0.00)
p1.x = 5 # direct access to property, bad idea
p1.y = 6
print(p1) # (5.00, 6.00)
p2 = Point(3, 4)
print(p2) # (3.00, 4.00)
print(p1 + p2) # (8.00, 10.00) Same as p1. add (p2)
print(p1) # (5.00, 6.00) No change
print(p2 * 3) # (9.00, 12.00) Same as p2. mul (3)
print(p2) # (9.00, 12.00) Changed 19
Python
MÉTODOS ESPECIALES
(MÁGICOS)
Magic Method Invoked Via Invocation Syntax
lt (self, right) Comparison Operators self < right
gt (self, right) self >
le (self, right) right self
ge (self, right) <= right
eq (self, right) self >=
ne (self, right) right self
== right
self !=
right
add (self, right) Arithmetic Operators self + right
sub (self, right) self -
mul (self, right) right self
truediv (self, right) * right
floordiv (self, right) self /
mod (self, right) right
pow (self, right) self //
right self
Python % right 20
self **
right
MÉTODOS ESPECIALES
(MÁGICOS)
Magic Method Invoked Via Invocation Syntax
and (self, right) Bitwise Operators self & right
or (self, right) self | right
xor (self, right) self ^
invert (self) right
lshift (self, n) ~self self
rshift (self, n) << n
self >> n
str (self) Function call str(self), print(self)
repr (self) repr(self)
sizeof (self) sizeof(self
)
len (self) Sequence Operators & len(self)
contains (self, item) Functions item in self
iter (self) iter(self) next(self)
next (self) self[key]
getitem__(self, key) self[key] =
setitem
Python
(self, key, value) value del 21
delitem__(self, key) self[key]
MÉTODOS ESPECIALES
(MÁGICOS)
Magic Method Invoked Via Invocation Syntax
int (self) Type Conversion Function int(self)
float (self) call float(sel
bool (self) f)
oct (self) bool(sel
hex (self) f)
oct(self)
hex(self)
init (self, *args) Constructor x = ClassName(*args)
new (cls, *args)
del (self) Operator del del x
index (self) Convert this object to an x[self]
index
radd (self, left) RHS (Reflected) addition, left + self
rsub (self, left) subtraction, etc. left - self
... ...
iadd (self, right) In-place addition, self += right
isub
Python (self, right)
subtraction, etc self -= right 22
... ...
MÉTODOS ESPECIALES
(MÁGICOS)
Magic Method Invoked Via Invocation Syntax
pos (self) Unary Positive and +self
neg (self) Negative operators -self
round__(self) Function Call round(self)
floor (self) floor(self)
ceil (self) ceil(self)
trunc (self) trunc(sel
f)
getattr (self, name) Object's attributes self.name
setattr (self, name, value) self.name =
delattr (self, name) value del
self.name
call (self, *args, Callable Object obj(*args, **kwargs);
**kwargs)
enter (self), exit (self) Context Manager with-
statement
Python 23
Variables de clase
• Son valores que pertenecen a la clase y no al objeto de la
clase.
• Las variables de clase se llaman también “variables
estáticas”
• Las variables de clase se declaran al mismo nivel que los
métodos.
• Las variables de clase siempre deben ser privadas para
asegurar que métodos de otras clases no cambian sus
valores. Las constantes de clase pueden ser públicas
Python 24
VARIABLES DE CLASE
- EJEMPLO
• Se desea asignar números de cuenta de banco
secuencialmente empezando por 1001.
class BankAccount :
_lastAssignedNumber = 1000 # A class variable
OVERDRAFT_FEE = 29.95 # Class constant
def _ _init_ _(self) :
self._balance = 0
BankAccount._lastAssignedNumber =
BankAccount._lastAssignedNumber + 1
self._accountNumber =
BankAccount._lastAssignedNumber
Python 25
MÉTODOS DE ACCESO (GET) Y
ASIGNACIÓN (SET)
• Mejora de la clase Circle con métodos get y set para
acceder las variables de instancia (circle1.py)
Python 26
MÉTODOS DE ACCESO (GET) Y
ASIGNACIÓN (SET)
"""circle.py: The circle module, which defines the Circle class"""
from math import pi
class Circle:
"""A Circle instance models a circle with a radius"""
def init (self, _radius = 1.0):
"""Initializer with default radius of 1.0"""
# Change from radius to _radius (meant for internal use)
# You should access through the getter and setter.
self.set_radius(_radius) # Call setter
def set_radius(self, _radius):
"""Setter for instance variable radius with input validation"""
if _radius < 0:
raise ValueError('Radius shall be non-negative')
self._radius = _radius
def get_radius(self):
"""Getter for instance variable
radius""" return self._radius
def get_area(self):
"""Return the area of this Circle
instance"""
Python return self.get_radius() * 27
self.get_radius() * pi
MÉTODOS DE ACCESO (GET) Y
...
ASIGNACIÓN (SET)
def repr (self):
"""Return a command string to recreate this instance"""
# Used by str() too as str () is not defined
return 'Circle(radius={})'.format(self.get_radius())
if name# Call
== 'getter
main ':
c1 = Circle(1.2) # Constructor and Initializer
print(c1) # Invoke repr (). Output:
Circle(radius=1.200000)
print(vars(c1)) # Output: {'_radius': 1.2}
print(c1.get_area()) # Output: 4.52389342117
print(c1.get_radius()) # Run Getter. Output: 1.2
c1.set_radius(3.4) # Test Setter
print(c1) # Output:
c1._radius = 5.6 Circle(radius=3.400000)
# Access instance variable directly (NOT
print(c1) # recommended but permitted)
c2 = Circle() # Default #radius
Output: Circle(radius=5.600000)
print(c2) # Output: Circle(radius=1.000000)
28
c3 = Circle(-5.6) # ValueError: Radius shall be non-negative
Python
HERENCIA -
JERARQUÍA
• En programación orientada a objetos, la herencia es una
relación entre:
– Una superclase: clase más general
– Una subclase: clase más especializada
• La subclase ‘hereda’ los datos (variables) y
comportamiento (métodos) de la superclase.
Python 29
JERARQUÍA DE LA
CLASE VEHICLE
• General
• Especializado
• Más específico
Python 30
LA SUPERCLASE OBJECT
• En Python, cada clase que es declarada sin una
superclase explícita, automáticamente extiende la
clase object.
Python 31
HERENCIA Y
POLIMORFISMO
• Se puede definir una clase Cylinder como una
subclase de Circle.
cylinde
r.py
Hereda atributo radius
y método get_area()
Python 32
HERENCIA
• cylinder.py un cilindro se puede derivar de un circulo
"""cylinder.py: which defines the Cylinder class"""
from circle import Circle # Using the Circle class
class Cylinder(Circle):
"""The Cylinder class is a subclass of Circle"""
def init (self, radius = 1.0, height = 1.0):
"""Constructor"""
super(). init (radius) # Invoke superclass
self.height = height
def str (self):
"""Self Description for print()"""
return 'Cylinder(radius=%.2f,height=%.2f)' %\
(self.radius, self.height)
def get_volume(self):
"""Return the volume of the cylinder"""
Python return self.get_area() * self.height 33
HERENCIA
• cylinder.py (cont.)
if name == ' main ':
cy1 = Cylinder(1.1, 2.2)
print(cy1)
print(cy1.get_area()) # inherited superclass' method
print(cy1.get_volume()) # Invoke its method
cy2 = Cylinder() # Default radius and height
print(cy2)
print(cy2.get_area())
print(cy2.get_volume())
print(dir(cy1))
print(Cylinder.get_area)
print(Circle.get_area)
c1 = Circle(3.3)
print(c1) # Output: circle with radius of
print(issubclass(Cylinder,
3.30 Circle)) # True
print(issubclass(Circle, Cylinder)) # False 34
print(isinstance(cy1, Cylinder)) # True
Python
SOBREESCRITURA
(OVERRIDING) DE MÉTODOS
• Se puede sobreescribir el método get_area( ) para
calcular la superficie del cilindro. También str
()
cylinder1.py
Python 35
EJEMPLO SHAPE Y
SUBCLASES
• shape.py
Python 36
HERENCIA
MÚLTIPLE
• minh.py
• minh1.py
• minh2.py
• minh3.py
Python 37
TIPO DE DATO DEFINIDO POR
EL USUARIO – CLASE CHARGE
• Se define un tipo Charge para partículas cargadas.
• Se usa la ley de Coulomb para el cálculo del potencial de un
punto debido a una carga V=kq/r , donde q es el valor de la
carga, r es la distancia del punto a la carga y k=8.99 × 109 N
m2/C2.
Constructor
Python 38
CONVENCIONES
SOBRE FICHEROS
• El código que define el tipo de dato definido por el
usuario Charge se coloca en un fichero del
mismo nombre (sin mayúscula) charge.py
• Un programa cliente que usa el tipo de dato Charge se
pone en el cabecero del programa:
from charge import Charge
Python 39
ELEMENTOS BÁSICOS DE UN
TIPO DE DATO
• API
• Clase. Fichero charge.py. Palabra reservada class
• Constructor. Método especial init (), self
• Variable de instancia. _nombrevar
• Métodos. Variable de instancia self
• Funciones intrínsecas. str()
40
• Privacidad
Python
IMPLEMENTACIÓN DE CLASE
CHARGE – FICHERO
import sys
import math
CHARGE.PY
class
Charge:
def self._rx = x0 # x value of the query point
init self._ry = # y value of the query
(self, y0 self._q = point # Charge
x0, y0,q0
def potentialAt(self, x, y):
q0):
COULOMB = 8.99e09
dx = x - self._rx
dy = y -
self._ry
r =
math.sqrt(dx*dx +
dy*dy)
if r == 0.0: # Avoid division by 0
if self._q >= 0.0:
return float('inf')
else:
return float('-inf')
return COULOMB * self._q /
r
Python 41
def str (self):
result = str(self._q) + ' at (' + str(self._rx) + ', ' +
CREACIÓN DE OBJETOS, LLAMADA
DE MÉTODOS Y REPRESENTACIÓN
DE STRING
Python 42
CLASE
COMPLEX
• Métodos especiales. En Python la expresión a b se
reemplaza con la llamada del método a. mul
(b)
Python 43
SOBRECARGA DE
OPERADORES
Python 44
Algoritmos de búsqueda
• Secuencial O(n)
• Búsqueda binaria O(logn)
Python 45
Algoritmos de ordenación
• Burbuja O(n2)
• Inserción O(n2)
• Selecció O(n2)
n O(n
• Mezcla logn)
• Quicksort O(n
logn)
Python 46
Estructuras de datos
• Pilas. Lista LIFO
• Colas. Lista FIFO
• Listas enlazadas
• Arboles
• Tabla de símbolos
• Grafos
Python 47
