Data">
Introducción A La Programación - Python
Introducción A La Programación - Python
Introducción A La Programación - Python
PROGRAMACIÓN
PYTHON
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
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
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"""
Python return self.radius * self.radius * pi 12
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)
#print(c1.color) # Error - c1 has no attribute 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.
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)
Python
return p 18
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)
19
print(p2) # (9.00, 12.00) Changed
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 self
pow (self, right) // right
Python
self % 20
right self
** right
MÉTODOS ESPECIALES
(MÁGICOS)
Magic Method Invoked Via Invocation Syntax
and (self, right) Bitwise Operators self & right
or (self, right) self |
xor (self, right) right self
invert (self) ^ right
lshift (self, n) ~self
rshift (self, n) self <<
n self
>> n
str (self) Function call str(self), print(self)
repr (self) repr(self)
sizeof (self) sizeof(sel
f)
len (self) Sequence Operators & len(self)
contains (self, Functions item in self
item) iter(self)
iter (self) next(self)
next (self) self[key]
getitem__(self,
Python key) self[key] = 21
... ...
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(se
lf)
getattr (self, name) Object's attributes self.name
setattr (self, name, self.name =
value) value del
delattr (self, name) self.name
call (self, *args, Callable Object obj(*args, **kwargs);
**kwargs)
enter (self), exit (self) Context Manager with-
statement
Python 23
Variables de clase
Python 25
MÉTODOS DE ACCESO (GET) Y
ASIGNACIÓN (SET)
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"""
return self.get_radius() * self.get_radius() * pi # Call getter
Python 27
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()) # Call getter
if name == ' 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: Circle(radius=3.400000)
c1._radius = 5.6 # Access instance variable directly (NOT
# recommended but permitted)
print(c1) # Output: Circle(radius=5.600000)
c2 = Circle() # Default radius
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
Python 31
HERENCIA Y POLIMORFISMO
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
Python 39
ELEMENTOS BÁSICOS DE UN TIPO
DE DATO
• API
Python 42
CLASE COMPLEX
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ón O(n2)
• Mezcla O(n logn)
• Quicksort O(n logn)
Python 46
Estructuras de datos
Python 47