Ing. Rubén Sanabria B.

Tabla de contenido
Escribir el título del capítulo (nivel 1) ............................................................................................................... 1
Escribir el título del capítulo (nivel 2) ............................................................................................................ 2
Escribir el título del capítulo (nivel 3) ........................................................................................................ 3
Escribir el título del capítulo (nivel 1) ............................................................................................................... 4
Escribir el título del capítulo (nivel 2) ............................................................................................................ 5
Escribir el título del capítulo (nivel 3) ........................................................................................................ 6

ING. RUBEN SANABRIA 1

 Ing. Rubén Sanabria B.

CAPITULO I

Estructuras de Datos en Python

1. Antecedentes

Introducción a la Orientación a Objetos

La programación orientada a objetos (POO) es una nueva manera de enfocar la programación. Desde sus
comienzos, la programación ha estado gobernada por varias metodologías. En cada punto crítico de la
evolución de la programación se creaba un nuevo enfoque para ayudar al programador a manejar
programas cada vez más complejos. Los primeros programas se crearon mediante un proceso de cambio
de los conmutadores del panel frontal de la computadora. Obviamente, este enfoque solo es adecuado
para programas pequeños. A continuación, se inventó el lenguaje ensamblador que permitió escribir
programas más largos. El siguiente avance ocurrió en los años 50 cuando se inventó el primer lenguaje de
alto nivel (FORTRAN).

Mediante un lenguaje de alto nivel, un programador estaba capacitado para escribir programas que
tuvieran una longitud de varios miles de líneas. Sin embargo, el método de programación usado en el
comienzo era un enfoque adhoc que no solucionaba mucho. Mientras que esto está bien para programas
relativamente cortos, se convierte en “código espagueti” ilegible y difícil de tratar cuando se aplica a
programas más largos. La eliminación del código espagueti se consiguió con la creación de los
lenguajes de programación estructurados en los años sesenta. Estos lenguajes incluyen ALGOL y PASCAL.
En definitiva, C es un lenguaje estructurado, y casi todos los tipos de programas que se han estado
haciendo se podrían llamar programas estructurados.

Los programas estructurados se basan en estructuras de control bien definidas, bloques de código, la
ausencia del GOTO, y subrutinas independientes que soportan recursividad y variables locales. La esencia
de la programación estructurada es la reducción de un programa a sus elementos constitutivos. Mediante
la programación estructurada un programador medio puede crear y mantener programas de una longitud
superior a 50,000 líneas.

Aunque la programación estructurada nos ha llevado a excelentes resultados cuando se ha aplicado a

programas moderadamente complejos, llega a fallar en algún punto cuando el programa alcanza un cierto
tamaño. Para poder escribir programas de mayor complejidad se necesitaba de un nuevo enfoque en la
tarea de programación. A partir de este punto nace la programación orientada a objetos (POO). La POO
toma las mejores ideas incorporadas en la programación estructurada y las combina con nuevos y potentes
conceptos que permiten organizar los programas de forma más efectiva. La POO permite descomponer un

ING. RUBEN SANABRIA 2

 Ing. Rubén Sanabria B.

problema en subgrupos relacionados. Cada subgrupo pasa a ser un objeto auto contenido que contiene sus
propias instrucciones y datos que le relacionan con ese objeto. De esta manera, la complejidad se reduce y
el programador puede tratar programas más largos.

Clases
Las clases proveen una forma de empaquetar datos y funcionalidad juntos. Al crear una nueva clase, se
crea un nuevo tipo de objeto, permitiendo crear nuevas instancias de ese tipo. Cada instancia de clase
puede tener atributos adjuntos para mantener su estado. Las instancias de clase también pueden tener
métodos (definidos por su clase) para modificar su estado.

Sintaxis de definición de clases

La forma más sencilla de definición de una clase se ve así:

class Clase:
<declaración-1>

<declaración-N>

Qué es un objeto
En Python, todos los tipos son objetos. Pero no en todos los lenguajes de programación es así. En general,
podemos decir que un objeto es una forma ordenada de agrupar datos (los atributos) y operaciones a
utilizar sobre esos datos (los métodos).

Es importante notar que cuando decimos objetos podemos estar haciendo referencia a dos cosas
parecidas, pero distintas.

Por un lado, la definición del tipo, donde se indican cuáles son los atributos y métodos que van a tener
todas las variables que sean de ese tipo. Esta definición se llama específicamente, la clase del objeto.

A partir de una clase es posible crear distintas variables que son de ese tipo. A las variables que son de una
clase en particular, se las llama instancia de esa clase.

NOTA Se dice que los objetos tienen estado y comportamiento, ya que los valores que tengan los atributos
de una instancia determinan el estado actual de esa instancia, y los métodos definidos en una clase
determinan cómo se va a comportar ese objeto.

Definiendo nuevos tipos

Sin bien Python nos provee con un gran número de tipos ya definidos, en muchas situaciones utilizar
solamente los tipos provistos por el lenguaje resultará insuficiente. En estas situaciones queremos poder
crear nuestros propios tipos, que almacenen la información relevante para el problema a resolver y
contengan las funciones para operar con esa información.

ING. RUBEN SANABRIA 3

 Ing. Rubén Sanabria B.

Por ejemplo, si se quiere representar un punto en el plano, es posible hacerlo mediante una tupla de dos
elementos, pero esta implementación es limitada, ya que si se quiere poder operar con distintos puntos
(sumarlos, restarlos o calcular la distancia entre ellos) se deberán tener funciones sueltas para realizar las
diversas operaciones.

Métodos especiales
Así como el constructor, _init_ , existen diversos métodos especiales que, si están definidos en nuestra
clase, Python los llamará por nosotros cuando se utilice una instancia en situaciones particulares.

Un método para mostrar objetos Para mostrar objetos, Python indica que hay que agregarle a la clase un
método especial, llamado __str__ que debe devolver una cadena de caracteres con lo que queremos
mostrar. Ese método se invoca cada vez que se llama a la función str.

El método __str__ tiene un solo parámetro, self.

Python es un lenguaje orientado a objetos. Esto significa que soporta herencia, polimorfismo y
encapsulamiento. Para lograr esto python nos deja crear los objetos por medio de las clases. Las clases no
son los objetos en si, sino son una descripción de cómo van a ser los objetos.

Al instanciar los objetos tendremos referencias a ellos y nunca tendremos a los objetos mismos. Esto pude
parecer muy teórico, pero en el día a día se hace notar.

Para definir una clases python nos facilita la palabra reservada “class”. Dentro de una clase definiremos los
métodos. Estos métodos serán definidos como definimos las funciones y los procedimientos por medio de
“def”.

Adentro de cada una de las clases podremos reverenciarnos a la instancia de cada uno por medio de “self”,
una especie de “yo mismo”, self es una referencia al mismo objeto (en otros lenguajes es this).

A cada método que creemos dentro de una clase tendremos que ponerle como primer parámetro a self.
Dentro de cada clase se podrá crear un constructor creando un método “def __init (self):”

Representación de una clase en Python

ING. RUBEN SANABRIA 4

 Ing. Rubén Sanabria B.

Todos los lenguajes de POO comparten tres características: encapsulación, polimorfismo y

herencia.

Encapsulación.
La encapsulación es el mecanismo que agrupa el código y los datos que maneja y los mantiene protegidos
frente a cualquier interferencia y mal uso. En un lenguaje orientado a objetos, el código y los datos suelen
empaquetarse de la misma forma en que se crea una “caja negra” autocontenida. Dentro de la caja son
necesarios tanto el código como los datos. Cuando el código y los datos están enlazados de esta manera, se
ha creado un objeto. En otras palabras, un objeto es el dispositivo que soporta encapsulación.

En un objeto, los datos y el código, o ambos, pueden ser privados para ese objeto o públicos. Los datos o el
código privado solo los conoce o son accesibles por otra parte del objeto. Es decir, una parte del programa
que esta fuera del objeto no puede acceder al código o a los datos privados. Cuando los datos o el código
son públicos, otras partes del programa pueden acceder a ellos, incluso aunque esté definido dentro de un
objeto. Normalmente, las partes públicas de un objeto se utilizan para proporcionar una interfaz
controlada a las partes privadas del objeto.

Para todos los propósitos, un objeto es una variable de un tipo definido por el usuario. Puede parecer
extraño que un objeto que enlaza código y datos se pueda contemplar como una variable. Sin embargo, en
programación orientada a objetos, este es precisamente el caso. Cada vez que se define un nuevo objeto,
se está creando un nuevo tipo de dato. Cada instancia específica de este tipo de dato es una variable
compuesta.

Hay ciertos métodos o atributos que queremos que pertenezcan sólo a la clase o al objeto, y que sólo
puedan ser accedidos por los mismos. Para ello podemos usar la doble __ para nombrar a un atributo o
método. Esto hará que Python los interprete como “privados”, de manera que no podrán ser accedidos
desde el exterior.

Ejemplo 1
class Clase:
atributo_clase = "Hola" # Accesible desde el exterior
__atributo_clase = "Hola" # No accesible

# No accesible desde el exterior

def __mi_metodo(self):
print("Haz algo")
self.__variable = 0

# Accesible desde el exterior

def metodo_normal(self):
# El método si es accesible desde el interior
self.__mi_metodo()

mi_clase = Clase()

ING. RUBEN SANABRIA 5

 Ing. Rubén Sanabria B.
#mi_clase.__atributo_clase # Error! El atributo no es accesible

#mi_clase.__mi_metodo() # Error! El método no es accesible

mi_clase.atributo_clase # Ok!
mi_clase.metodo_normal() # Ok!

Polimorfismo.
Polimorfismo (del Griego, cuyo significado es “muchas formas”) es la cualidad que permite que un
nombre se utilice para dos o más propósitos relacionados pero técnicamente diferentes. El propósito del
polimorfismo aplicado a la POO es permitir poder usar un nombre para especificar una clase general de
acciones. Dentro de una clase general de acciones, la acción específica a aplicar está determinada por el
tipo de dato. Por ejemplo, en C, que no se basa significativamente en el polimorfismo, la acción de valor
absoluto requiere tres funciones distintas: abs(), labs() y fabs(). Estas tres funciones calculan y devuelven el
valor absoluto de un entero, un entero largo y un valor real, respectivamente. Sin embargo, en C++, que
incorpora polimorfismo, a cada función se puede llamar abs().

El tipo de datos utilizado para llamar a la función determina que versión específica de la función se está
usando, es decir, es posible usar un nombre de función para propósitos muy diferentes. Esto se llama
sobrecarga de funciones. De manera general, el concepto de polimorfismo es la idea de “una interfaz,
múltiples métodos”. Esto significa que es posible diseñar una interfaz genérica para un grupo de
actividades relacionadas. Sin embargo, la acción específica ejecutada depende de los datos. La
ventaja del polimorfismo es que ayuda a reducir la complejidad permitiendo que la misma interfaz se
utilice para especificar una clase general de acción.

Es trabajo del compilador seleccionar la acción específica que se aplica a cada situación. El programador no
necesita hacer esta selección manualmente, solo necesita recordar y utilizar la interfaz general.

El polimorfismo se puede aplicar tanto a funciones como a operadores, prácticamente todos los lenguajes
de programación contienen una aplicación limitada de polimorfismo cuando se relaciona con los
operadores aritméticos, por ejemplo, en C, el signo + se utiliza para añadir enteros, enteros largos,
caracteres y valores reales. En estos casos, el compilador automáticamente sabe qué tipo de aritmética
debe aplicar, en C++, se puede ampliar este concepto a otros tipos de datos que se definan, este tipo de
polimorfismo se llama sobrecarga de operadores.

En Python, el polimorfismo es una forma de hacer que una función acepte objetos de diferentes clases si se
comportan de manera similar.

ING. RUBEN SANABRIA 6

 Ing. Rubén Sanabria B.

Hay cuatro formas de implementar polimorfismo en Python:

1. Duck Typing : el Duck Typing es un concepto que dice que el "tipo" del objeto es un motivo de
preocupación solo en tiempo de ejecución y no es necesario mencionar explícitamente el tipo de objeto
antes de realizar cualquier tipo de operación en ese objeto, a diferencia de la escritura normal donde la
idoneidad de un objeto está determinada por su tipo.

En Python, tenemos el concepto de tipado dinámico, es decir, podemos mencionar el tipo de variable /
objeto más adelante. La idea es que no necesita un tipo para invocar un método existente en un objeto si
un método está definido en él, puede invocarlo.

class Geeks1:
def code(self, ide):
[Link]()

class Geeks2:
def execute(self):
print("GeeksForGeeks is the best Platform for learning")

ide = Geeks2()

G1 = Geeks1()

[Link](ide)

Salida:

GeeksForGeeks es la mejor plataforma para aprender

ING. RUBEN SANABRIA 7

 Ing. Rubén Sanabria B.
2. Sobrecarga de métodos: de forma predeterminada, Python no admite la sobrecarga de métodos, pero
podemos lograrlo modificando los métodos.

Dada una sola función sum(), usted puede especificar el número de parámetros. Este proceso de llamar al
mismo método de diferentes formas se denomina sobrecarga de método .

Concepto de sobrecarga de métodos

class GFG:
def sum(self, a = None, b = None, c = None):
s = 0
if a != None and b != None and c != None:
s = a + b + c
elif a != None and b != None:
s = a + b
else:
s = a
return s

s = GFG()

print([Link](1))

print([Link](3, 5))

print([Link](1, 2, 3))

Salida:

1
8
6

ING. RUBEN SANABRIA 8

 Ing. Rubén Sanabria B.
3. Sobrecarga de operadores : La sobrecarga de operadores en Python es la capacidad de un solo operador
para realizar más de una operación según la clase(tipo) de operandos. Entonces, básicamente definir
métodos para operadores se conoce como sobrecarga de operadores. Por ejemplo: Para usar el operador +
con objetos personalizados, necesita definir un método llamado __add__.

Sabemos que el operador + se usa para sumar números y al mismo tiempo para concatenar cadenas. Es
posible porque el operador + está sobrecargado por tanto la clase int y clase str . Los operadores son en
realidad métodos definidos en clases respectivas.

Entonces, si desea usar el operador + para agregar dos objetos de alguna clase definida por el usuario,
tendrá que definir ese comportamiento usted mismo e informar a Python sobre eso.

class Student:
def __init__(self, m1, m2):
self.m1 = m1
self.m2 = m2

S1 = Student(58, 60)
S2 = Student(60, 58)

S3 = S1 + S2

Salida:

TypeError: tipos de operandos no admitidos para +: 'Estudiante' y 'Estudiante'

Entonces podemos ver que el operador + no es compatible con una clase definida por el usuario. Pero
podemos hacer lo mismo sobrecargando el operador + para nuestra clase.

class Student:

def __init__(self, m1, m2):

self.m1 = m1
self.m2 = m2

def __add__(self, other):

m1 = self.m1 + other.m1
m2 = self.m2 + other.m2
s3 = Student(m1, m2)
return s3

s1 = Student(58, 59)
s2 = Student(60, 65)
s3 = s1 + s2
print(s3.m1)

Salida:

ING. RUBEN SANABRIA 9

 Ing. Rubén Sanabria B.
118

4. Anulación de método: al utilizar la anulación de método, una clase puede "copiar" otra clase, evitando el
código duplicado y, al mismo tiempo, mejorar o personalizar una parte de ella. La invalidación del método
es, por tanto, parte del mecanismo de herencia.

En Python, la invalidación de métodos se produce simplemente definiendo la clase secundaria en un

método con el mismo nombre que un método en la clase principal.

class Programming:

DataStructures = True
Algorithms = True

def practice(self):
print("Practice makes a man perfect")

def consistency(self):
print("Hard work along with consistency can defeat Talent")

class Python(Programming):

def consistency(self):
print("Hard work along with consistency can defeat Talent.")

Py = Python()
[Link]()
[Link]()

Salida:

El trabajo duro junto con la coherencia pueden derrotar al talento.

La práctica hace que un hombre sea perfecto

Herencia.
La herencia es el proceso mediante el cual un objeto puede adquirir las propiedades de otro. Más en
concreto, un objeto puede heredar un conjunto general de propiedades a alas que puede añadir aquellas
características que son específicamente suyas. La herencia es importante porque permite que un objeto
soporte el concepto de clasificación jerárquica. Mucha información se hace manejable gracias a esta
clasificación, por ejemplo, la descripción de una casa. Una casa es parte de una clase general llamada
edificio, a su vez, edificio es una parte de la clase más general estructura, que es parte de la clase aún más
general de objetos que se puede llamar obra hombre.

ING. RUBEN SANABRIA 10

 Ing. Rubén Sanabria B.
En cualquier caso, la clase hija hereda todas las cualidades asociadas con la clase padre y le añade sus
propias características definitorias. Sin el uso de clasificaciones ordenadas, cada objeto tendría que definir
todas las características que se relacionan con él explícitamente.

Sin embargo, mediante el uso de la herencia, es posible describir un objeto estableciendo la clase general
(o clases) a las que pertenece, junto con aquellas características específicas que le hacen único.

Ejemplo

Se puede crear una clase hija con tan solo pasar como parámetro la clase de la que queremos heredar. En el
siguiente ejemplo vemos cómo se puede usar la herencia en Python, con la clase Perro que hereda de Animal.
Así de fácil.

# Definimos una clase padre

class Animal:
pass

# Creamos una clase hija que hereda de la padre

class Perro(Animal):
pass

De hecho podemos ver como efectivamente la clase Perro es la hija de Animal usando __bases__

print(Perro.__bases__)
# (<class '__main__.Animal'>,)

Ejemplo 2

Definimos la clase padre, con una serie de atributos comunes para todos los animales como hemos
indicado.
class Animal:
def __init__(self, especie, edad):
[Link] = especie
[Link] = edad

# Método genérico pero con implementación particular

def hablar(self):
# Método vacío
pass

# Método genérico pero con implementación particular

def moverse(self):
# Método vacío
pass

# Método genérico con la misma implementación

def describeme(self):
print("Soy un Animal del tipo", type(self).__name__)

ING. RUBEN SANABRIA 11

 Ing. Rubén Sanabria B.

Ejemplo 3

Como ejemplo vamos a crear una clase vacía, para ver como los métodos y atributos son heredados por
defecto.
# Perro hereda de Animal
class Perro(Animal):
pass

mi_perro = Perro('mamífero', 10)

mi_perro.describeme()
# Soy un Animal del tipo Perro

Tipos de Datos Abstractos

Abstracción: consiste en ignorar los detalles de la manera particular en que está hecha una cosa,
quedándonos solamente con su visión general. Tipo de Dato Abstracto (TDA) se define como un conjunto
de valores que pueden tomar los datos de ese tipo, junto a las operaciones que los manipulan.

Un TDA es un modelo matemático de estructuras de datos que especifican los tipos de datos almacenados,
las operaciones definidas sobre esos datos y los tipos de parámetros de esas operaciones.

TAD = Valores (tipo de dato) + operaciones

Un TDA define lo que cada operación debe hacer, más no como la debe hacer. En un lenguaje de
programación como Java un TDA puede ser expresado como una interface, que es una simple lista de
declaraciones de métodos.

Un TDA es materializado por una estructura de datos concreta, en Java, es modelada por una clase. Una
clase define los datos que serán almacenados y las operaciones soportadas por los objetos que son
instancia de la clase. Al contrario de las interfaces, las clases especifican como las operaciones son
ejecutadas (implementación).

Ejemplos de tipos de datos abstractos son las Listas, Pilas, Colas, etc., que se discutirán más adelante.

Estructuras de Datos
En programación, una estructura de datos es una forma de organizar un conjunto de datos elementales (un
dato elemental es la mínima información que se tiene en el sistema) con el objetivo de facilitar la
manipulación de estos datos como un todo y/o individualmente.

Una estructura de datos define la organización e interrelaciona miento de estos, y un conjunto de

operaciones que se pueden realizar sobre él. Las operaciones básicas son:

Alta, adicionar un nuevo valor a la estructura.

ING. RUBEN SANABRIA 12
 Ing. Rubén Sanabria B.
Baja, borrar un valor de la estructura.

Búsqueda, encontrar un determinado valor en la estructura para se realizar una operación con este valor,
en forma SECUENCIAL o BINARIO (siempre y cuando los datos estén ordenados).

Otras operaciones que se pueden realizar son:

Ordenamiento, de los elementos pertenecientes a la estructura.

Apareo, dadas dos estructuras originar una nueva ordenada y que contenga a las apareadas.

Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y eficiencia para la realización de
cada operación. De esta forma, la elección de la estructura de datos apropiada para cada problema
depende de factores como las frecuencias y el orden en que se realiza cada operación sobre los datos.

Algunas estructuras de datos utilizadas en programación son:

Estructuras estáticas y dinámicas:

ESTATICAS DINAMICAS
Simples o fundamentales Pilas
Boolean Colas
Char Listas
Integer Simples enlazadas
Real Dobles enlazadas
Compuestas o estructurados Circulares enlazadas
String Arboles
Arreglos Binarios
Conjuntos Multicaminos
Registros Grafos
Archivos

1- Calcula la distancia entre 2 puntos, ingrese datos por teclado

import math
class Distancia:
def __init__(self):

ING. RUBEN SANABRIA 13

 Ing. Rubén Sanabria B.
self.x1 = 0
self.x2 = 0
self.y1 = 0
self.y2 = 0
[Link] = 0

def IngresaDatos(self):
self.x1 = int(input("Ingrese x1 : "))
self.Y1 = int(input("Ingrese Y1 : "))
self.x2 = int(input("Ingrese x2 : "))
self.x2 = int(input("Ingrese Y2 : "))

def CalculaDatos(self):
[Link] = [Link](pow((self.x2-self.x1),2)+pow((self.y2-self.y1),2))
return print("La distancia es :{0:.2f}".format([Link]))

objeto = Distancia()
[Link]()
[Link]()

2- Hallar el área y el perímetro de un cuadrado, ingrese el lado

import math
class Cuadrado:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = 0

def IngreseLado(self):
[Link] = float(input("Ingrese lado "))

def CalculaArea(self):
[Link] = pow([Link],2)
return print("El area es {0:.2f}".format([Link]))

def CalculaPerimetro(self):
[Link] = [Link]*4
return print("El perimetro es {0:.2f}".format([Link]))

ING. RUBEN SANABRIA 14

 Ing. Rubén Sanabria B.

cuadrado = Cuadrado()
[Link]()
[Link]()
[Link]()

3-Hallar el área y el perímetro de un rectángulo, ingrese los lados correspondientes

class Rectangulo:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0

def IngreseLados(self):
[Link] = float(input("Ingrese el lado A : "))
[Link] = float(input("Ingrese el lado B : "))

def CalculaArea(self):
[Link] = [Link]*[Link]
return print("el area es {0:.2f}".format([Link])+" m2")

def CalculaPerimetro(self):
[Link] = 2*([Link]+[Link])
return print("el perimetro hallado :{0:.2f}".format([Link]))

rectangulo = Rectangulo()
[Link]()
[Link]()
[Link]()

ING. RUBEN SANABRIA 15

 Ing. Rubén Sanabria B.

4-Hallar el área y el perímetro de un rombo, cuya diagonal mayor es de 8cm, la diagonal menor 6cm.
import math
class Rombo:
def __init__(self):
self.d1 = 8
self.d2 = 6
[Link] = 0
[Link] = 0
[Link] = 0

def CalculaArea(self):
[Link] = (self.d1*self.d2)/2
return print("Area del rombo {0:.2f}".format([Link])+" cm2")

def CalculaPerimetro(self):
#como no tenemos los lados, debemos calcularlos
#descompones en 4 triangulos, hallamos hipotenusa, la altura
#seria d1/2, la base d2/2
#l al cuadrado =
#d1/2 = 4 y d2/2=3
[Link] = [Link](16+9)
[Link] = [Link]*4
return print("el lado hallado es {0:.2f}".format([Link])+"\n"
+"el perimetro es {0:.2f}".format([Link]))

rombo = Rombo()
[Link]()
[Link]()

Resultado

Área del rombo 24.00 cm2

el lado hallado es 5.00
el perímetro es 20.00

5- Hallar la diagonal mayor de un rombo, sabiendo que la diagonal menor es de 16cm y su superficie de
192 cm2.

ING. RUBEN SANABRIA 16

 Ing. Rubén Sanabria B.
import math
class Rombo:
def __init__(self):
self.d1 = 0
self.d2 = 16
[Link] = 192
[Link] = 0
[Link] = 0

def calculaDMayor(self):
#despejando la formula
self.d1 = (192*2)/16
return print("la diagonal mayor es {0:.2f}".format(self.d1))

def calculaPerimetro(self):
#no tengo el lado
#hallamos por pitagoras
[Link] = [Link](144+64)
[Link] = [Link]*4
return print("el lado hallado es {0:.2f}".format([Link])
+"\n el perimetro es {0:.2f}".format([Link]))

rombo = Rombo()
[Link]()
[Link]()

Resultado:

la diagonal mayor es 24.00

el lado hallado es 14.42
el perímetro es 57.69

6- Hallar el perímetro y el área de un pentágono, cuyo lado mide 7cm, y su apotema es de 5cm
class Pentagono:
def __init__(self):
[Link] = 7.2
[Link] = 5
[Link] = 0

ING. RUBEN SANABRIA 17

 Ing. Rubén Sanabria B.
[Link] = 0

def CalculaPerimetro(self):
[Link] = [Link] * 5
return print("Perimetro es : {0:.2f}".format([Link]))

def CalculaArea(self):
[Link] = ([Link] * [Link])/2
return print("Area del pentagono {0:.2f}".format([Link]))

pentagono = Pentagono()
[Link]()
[Link]()

7- Hallar el perímetro y el área, y apotema de un pentágono, cuyo lado mide 6cm

import math
class Pentagono:
def __init__(self):
[Link] = 6
[Link] = 0
[Link] = 0
[Link] = 0

def CalculaPerimetro(self):
[Link] = [Link] * 5
return print("Perimetro es : {0:.2f}".format([Link]))

def CalculaApotema(self):
"""
para hallar el apotema de un poligono regular
Ap = (lado)/2*tanO y O=360grados/2*ladotriangulitos
O=360/2*10 ===>O=36
"""
[Link] = ([Link])/2*[Link](36)
return print("el apotema hallado es {0:.2f}".format([Link]))

def CalculaArea(self):
[Link] = ([Link] * [Link])/2
return print("Area del pentagono {0:.2f}".format([Link]))

pentagono = Pentagono()
[Link]()
[Link]()
[Link]()

Resultado:

Perímetro es : 30.00
el apotema hallado es 23.25
Area del pentágono 348.77 cm2

ING. RUBEN SANABRIA 18

 Ing. Rubén Sanabria B.

8-- Calcular el área de un círculo y la longitud de una circunferencia, cuyo radio se ingresa por teclado
import math
class Circulo:
def init (self):
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0

def hallaArea(self):
[Link] = 3.14 * pow([Link],2)
return print("El area es {0:.2f}".format([Link]))

def hallaLongitud(self):
[Link] = 2 * 3.14 * [Link]
return print("La longitud es {0:.2f}".format([Link]))

circulo = Circulo()
[Link] = float(input("ingrese el radio "))
[Link]()
[Link]()

Resultado:

ingrese el radio 12
El area es 452.16
La longitud es 75.36

ING. RUBEN SANABRIA 19

 Ing. Rubén Sanabria B.

8-- Calcular el área y volumen de un cubo, cuyo lado se ingresa por teclado
import math

class Cubo:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = 0

def IngresaLado(self):
[Link] = float(input("Ingresa el lado : "))

def CalculaArea(self):
[Link] = 6*[Link]([Link],2)
return print("el area es {0:.2f}".format([Link]))

def CalculaVolumen(self):
[Link] = [Link]([Link],3)
return print("el volumen es {0:.2f}".format([Link]))

cubo = Cubo()
[Link]()
[Link]()
[Link]()

Resultado:
Ingresa el lado : 7
el area es 294.00
el volumen es 343.00

9- Halla el área y volumen de una esfera, ingrese los elementos correspondientes:

ING. RUBEN SANABRIA 20

 Ing. Rubén Sanabria B.

10- Implemente una clase para almacenar una temperatura dada en grados centígrados y la convierta
a grados Fahrenheit, de acuerdo a la fórmula (despeje la variable):

ºC = 5 (ºF – 32)/ 9

Utilice el siguiente diagrama de la clase en UML:

class Grados:
def init (self):
[Link] = 0
[Link] = 0
[Link] = 0

def convertiraGrado(self):
[Link] = (5*([Link] - 32))/9
return print("A grados {0:.2f}".format([Link]))

def convertiraFahrenheit(self):
[Link] = (([Link] * 9)+32)/5
return print("A Fahrenheit {0:.2f}".format([Link]))

grados = Grados()
[Link] = float(input("ingrese Grado "))
print("Grado ingresado ",[Link])
[Link]()
[Link] = float(input("ingrese Fahrenheit "))
print("Fahrenheit ingresado ",[Link])
[Link]()

ING. RUBEN SANABRIA 21

 Ing. Rubén Sanabria B.
Resultado :
ingrese Grado 35
Grado ingresado 35.0
A Fahrenheit 69.40
ingrese Fahrenheit 78
Fahrenheit ingresado 78.0
A grados 25.56

11- Una persona desea cambiar guaraníes a dólares y requiere un conversor de divisas, hacer un
programa que solucione el problema:

Cree un objeto e inicialice el tipo de cambio, luego asigne la cantidad de pesos e imprima la
conversión a dólares.
class CambioDivisas:
def init (self):
[Link] = 0
[Link] = 0
[Link] = 0

def aDolares(self):
[Link] = ([Link]/[Link])
return print("A Dolares {0:.2f}".format([Link]))

def aGuaranies(self):
[Link] = ([Link] * [Link])
return print("A Guaranies {0:.2f}".format([Link]))

convertir = CambioDivisas()
[Link] = float(input("la Cotizacion de hoy "))
[Link] = float(input("Ingrese el monto "))
[Link]()
[Link]()

Resultado :
la Cotizacion de hoy 6870

ING. RUBEN SANABRIA 22

 Ing. Rubén Sanabria B.
Ingrese el monto 15000000
A Dolares 2183.41
A Guaranies 15000000.00

Ejemplo de herencia
12- Se tiene el siguiente diagrama de UML, hallar los elementos pedidos en las clases respectivas

Las medidas se darán en cm.

import math
class Figura(object):
def __init__ (self):
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0

class Rectangulo(Figura):
def calcularArea(self):
[Link] = [Link] * [Link]
return print("Area Rectangulo {0:.2f}".format([Link])+" cm2")

def calcularPerimetro(self):
[Link] = 2*([Link] + [Link])
return print("Perimetro Rectangulo {0:.2f}".format([Link])+" cm")

class Circunferencia(Figura):

ING. RUBEN SANABRIA 23

 Ing. Rubén Sanabria B.
def calcularArea(self):
[Link] = ([Link] * pow([Link],2))
return print("Area Cia {0:.2f}".format([Link])+" cm2")

def calculaPerimetro(self):
[Link] = 2 * [Link] * [Link]
return print("Perimetro de la Cia es {0:.2f}".format([Link])+" cm")

rectangulo = Rectangulo()
[Link] = float(input("ingrese lado A: "))
[Link]= float(input("ingrese lado B: "))
[Link]()
[Link]()

cia = Circunferencia()
[Link] = float(input("ingresa Radio : "))
[Link]()
[Link]()

Resultado :
ingrese lado A: 4
ingrese lado B: 7
Area Rectangulo 28.00 cm2
Perimetro Rectangulo 22.00 cm
ingresa Radio : 11
Area Cia 380.13 cm2
Perimetro de la Cia es 69.12 cm

13- Una empresa desea un sistema capaz de calcular el salario semanal de sus empleados de acuerdo a
la cantidad de horas trabajadas, el sueldo por hora y tomando en cuenta los siguientes criterios:
Se debe ingresar el salario básico, salario por hora
 Si las horas trabajadas son más de 40, entonces el excedente se considera hora extra.
 Si las horas trabajadas están entre el rango de 41 a 45, entonces cada hora extra se paga doble.
 Si las horas trabajadas son más de 45, entonces cada hora extra se paga triple.
Implemente el sistema de acuerdo al siguiente diagrama de clases en UML:

ING. RUBEN SANABRIA 24

 Ing. Rubén Sanabria B.

ING. RUBEN SANABRIA 25

 Ing. Rubén Sanabria B.

Estructuras Estáticas
Arreglos
En muchas situaciones necesitamos procesar una colección de valores que están relacionados entre si por
algún método, por ejemplo, una series de temperaturas medidas a lo largo del mes, etc.

Si usamos datos simples, esto puede llegar a ser muy tediosos y extremadamente complicado, por lo que
la mayoría de los lenguajes de programación incluyen características de estructura de datos.

La estructura de datos básica que soportan la mayoría de los lenguajes de programación son los arreglos
(El concepto análogo será los vectores o matrices). Un arreglo es una secuencia de posiciones de la
memoria central a las que se puede acceder directamente, que contiene datos del mismo tipo y pueden
ser seleccionados individualmente mediante el uso de subíndices. Un arreglo es un conjunto finito y
ordenado de elementos homogéneos.

ING. RUBEN SANABRIA 26

 Ing. Rubén Sanabria B.
La propiedad “ordenado” significa que el elemento primero, segundo, tercero,∙∙∙, enésimo de un arreglo
puede ser identificado. Los elementos de un arreglo son homogéneos, es decir, del mismo tipo de datos.
Un arreglo puede estar compuesto de todos sus elementos de tipo “carácter”, otro puede tener
elementos de tipo “integer”, etc.

Arreglos unidimensionales
El tipo más simple de arreglo es el arreglo unidimensional. El análogo de los arreglos unidimensionales son
los vectores o mejor dicho matrices de rango 1. Sea un vector de una dimensión denominado VECTOR,
que consta de n elementos se puede representar como: VECTOR(1) VECTOR(2) . . . VECTOR(I) . . .
VECTOR(N)

El término en paréntesis denomina el lugar que tendrá en la computadora. Como ejemplo de un arreglo
unidimensional, se puede considerar el vector TEMPERATURA que contiene las temperaturas de cada hora
registradas en una ciudad durante un día. Este vector constara de veinticuatro elementos de tipo real

Cada elemento de un vector se puede procesar como si fuera una variable simple al ocupar una posición
de la memoria.

Las operaciones que se pueden utilizar con vectores durante el proceso de resolución de un problema
son:

 asignación
 lectura y escritura
 recorrido (acceso secuencial)
 actualizar (añadir, borrar, insertar)
 ordenación búsqueda.

En general, las operaciones con vectores implican el procesamiento o tratamiento de los elementos
individual del vector.

Arreglos de varias dimensiones

Se puede definir matrices como arreglos multidimensionales, cuyos elementos se pueden referenciar por
dos, tres o más subíndices.

Los arreglos no unidimensionales los dividiremos en dos grandes grupos: arreglos bidimensionales (2-d)
arreglos multidimensionales (3-d, o más).

Arreglos bidimensionales
El arreglo bidimensional se puede considerar como un vector de vectores, de manera más intuitiva una
matriz. Es por consiguiente, un conjunto de elementos, todos del mismo tipo, en el cual, el orden de los
componentes es significativo y en el que se necesita especificar dos índices para poder identificar cada
elemento del arreglo.

ING. RUBEN SANABRIA 27

 Ing. Rubén Sanabria B.
Sin embargo, un subíndice no es suficiente para especificar un elemento de un arreglo bidimensional: por
ejemplo, si el nombre del arreglo es M, no se puede indicar M[3], ya que no sabemos si es el tercer
elemento de la primera fila o de la primera columna. Para evitar la ambigüedad, los elementos de un
arreglo bidimensional se referirán con dos subíndices: el primer subíndice se refiere a la fila y el segundo
subíndice se refiere a la columna. Por consiguiente M[2,3] se refiere al elemento de la segunda fila,
tercera columna.

El elemento B[i, j] también se puede representar por Bij . Donde i = 1, ∙ ∙ ∙ , M, o bien 1 ≤ i ≤ M y j = 1, ∙ ∙ ∙ ,

No1≤j≤N

En general, se considera que un arreglo bidimensional comienzan sus subíndices en 1, pero puede tener
limites seleccionados por el usuario durante la elaboración del algoritmo. En general, el arreglo
bidimensional B con su primer subíndice, variando desde un límite inferior a un límite superior. B[L1:U1,
L2:U2] = (B[I,J]) donde L1 ≤ i ≤ U1 y L2 ≤ j ≤ U2.

Arreglos o vectores, representación

Ejercicios

1-Se tiene un vector con los siguientes elementos [3,4,5,2,8}, sumar los elementos del vector
class Vector:
def __init__(self):
[Link] = 0
[Link] = [3,4,5,2,8]

def calcularSuma(self):
for i in range(5):
[Link] = [Link] + [Link][i]

def mostrarVector(self):
print("Vector Dado \n")
for i in range(5):
print([Link][i],end=" ")
print("\n")

def mostrarResultado(self):
print("la suma de elementos es {:.2f}".format([Link]))
print("\n")

arreglo = Vector()

ING. RUBEN SANABRIA 28

 Ing. Rubén Sanabria B.
[Link]()
[Link]()
[Link]()

Resultado

Vector Dado

34528

la suma de elementos es 22.00

2 – El ejercicio anterior hallando el promedio de los elementos hallados

class Vector:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = [3, 4, 5, 2, 8]

def calcularSuma(self):
for i in range(5):
[Link] = [Link] + [Link][i]
[Link] = [Link] + 1
[Link] = [Link] / [Link]

def mostrarResultado(self):
print("la suma del vector es {:.2f}".format([Link]))
print("se hallo {:.2f} elementos ".format([Link]))
print("el promedio hallado es {:.2f}".format([Link]))

arreglo = Vector()
[Link]()
[Link]()

3-Hallar la suma de elementos del vector ingresando los datos por teclado, tanto los elementos como la
dimensión del vector.

class Vector:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = []

def ingresaTamanio(self):
[Link] = int(input("ingresa tamaño "))

def ingresaElementos(self):

ING. RUBEN SANABRIA 29

 Ing. Rubén Sanabria B.
for i in range([Link]):
[Link](int(input("ingrese elemento ")))

def sumar(self):
for i in range([Link]):
[Link] = [Link] + [Link][i]
print("la suma hallada es {:.2f}".format([Link]))

vector = Vector()
[Link]()
[Link]()
[Link]()

Resultado:
ingresa tamaño 5
ingrese elemento 1
ingrese elemento 2
ingrese elemento 3
ingrese elemento 4
ingrese elemento 5
la suma hallada es 15.00

4-Crear un vector V de N componentes y sumar todos los elementos del vector que sean pares por
un lado e impares por el otro, hallar ambos promedios.
class Vector:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = []

def ingresaTamanio(self):
[Link] = int(input("ingresa tamaño : "))

def ingresaElemento(self):
for i in range([Link]):
[Link](int(input("ingrese elemento ")))

def calcular(self):
for i in range([Link]):
if([Link][i] % 2 == 0):
[Link] = [Link] + [Link][i]
[Link] = [Link] + 1
else :
[Link] = [Link] + [Link][i]
[Link] = [Link] + 1

ING. RUBEN SANABRIA 30

 Ing. Rubén Sanabria B.
def mostrar(self):
[Link] = [Link]/[Link]
[Link] = [Link]/[Link]
print("el promedio par es ", [Link])
print("el promedio impar es ", [Link])

vec = Vector()
[Link]()
[Link]()
[Link]()
[Link]()

Resultado:

ingresa tamaño : 6
ingrese elemento 11
ingrese elemento 27
ingrese elemento 2
ingrese elemento 4
ingrese elemento 6
ingrese elemento 8
el promedio par es 5.0
el promedio impar es 19.0

5-Cuántas veces en el vector se encuentra el digito 2?, defina el tamaño y la carga de elementos del
vector correspondiente.
class Vector:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = []

def ingresaTamanio(self):
[Link] = int(input("ingresa tamaño : "))

def ingresaElemento(self):
for i in range([Link]):
[Link](int(input("ingrese elemento ")))

def calcular(self):
for i in range([Link]):
if ([Link][i] == 2):
[Link] = [Link] + 1
print("la cantidad de 2 en el vector son {0:.2f}".format([Link]))

vector = Vector()
[Link]()
[Link]()
[Link]()

ING. RUBEN SANABRIA 31

 Ing. Rubén Sanabria B.

resultado
ingresa tamaño : 5
ingrese elemento 1
ingrese elemento 2
ingrese elemento 3
ingrese elemento 2
ingrese elemento 5
la cantidad de 2 en el vector son 2.00

MATRICES
Podemos decir que una matriz, es una disposición bidimensional de elementos, que comprende filas y
columnas.

Las matrices no son una estructura propia de Python. Simplemente, una matriz es una lista de listas que
nosotros interpretamos desde el punto de vista matemático.

ING. RUBEN SANABRIA 32

 Ing. Rubén Sanabria B.
Es decir la estructura m = [[1,2],[3,4]] nosotros la interpretamos como la matriz 2x2 cuya primera fila es
(1,2) y cuya segunda fila es (3,4), pero esto no deja de ser una interpretación.

Sencillamente, las matrices son listas, dentro de otroa lista. Sí, así es, podemos decir que es una lista
bidimensional, 2x2.

Supongamos que tenemos la matriz: [[4,3],[9,3]]. La primera fila de esta matriz es (4,3) y la segunda (9,3).

En Python nos quedaria algo así:

a = [[4,3],[9,3]]
print(a)

[[4, 3], [9, 3]]

Algunas operaciones matemáticas con matrices

1-Se tiene una matriz dada de 2x3, visualizar la matriz.

matriz = [[2,5,6],[4,7,1]]
print(matriz)

Resultado

[[2, 5, 6], [4, 7, 1]]

2- Crear una matriz, definir el tamaño de dicha matriz, luego ingresar los elementos, imprimir la matriz
creada.

class Matriz:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = []

def ingreseDimension(self):

ING. RUBEN SANABRIA 33

 Ing. Rubén Sanabria B.
[Link] = int(input("ingrese fila "))
[Link] = int(input("ingrese columna "))
for f in range([Link]):
[Link]([0]*[Link])

def ingresaDatos(self):
for f in range([Link]):
for c in range([Link]):
[Link][f][c] = int(input("elemento %d,%d:"%(f,c)))

def mostrarMatriz(self):
print("matriz resultante")
for f in range([Link]):
for c in range([Link]):
print([Link][f][c],end=' ')
print()

matriz = Matriz()
[Link]()
[Link]()
[Link]()

resultado:

ingrese fila 3
ingrese columna 3
elemento 0,0:1
elemento 0,1:2
elemento 0,2:3
elemento 1,0:4
elemento 1,1:5
elemento 1,2:6
elemento 2,0:7
elemento 2,1:8
elemento 2,2:9
matriz resultante
123
456
789

3- Dada un matriz[][], con los siguientes elementos [[5,6,7,8],[4,3,2,1],[9,10,11,12]], sumar los elementos
de la matriz

class Matriz:
def __init__(self):
[Link] = 0
[Link] = 0
[Link] = 0
[Link] = [[5,6,7,8],[4,3,2,1],[9,10,1,12]]

ING. RUBEN SANABRIA 34

 Ing. Rubén Sanabria B.

def sumarElementos(self):
[Link] = 3
[Link] = 4
for f in range([Link]):
for c in range([Link]):
[Link] = [Link] + [Link][f][c]
print("la suma es {:.2f}".format([Link]))

matriz = Matriz()
[Link]()

resultado:
la suma es 68.00

4- Crear una matriz, definir el tamaño de dicha matriz, luego ingresar los elementos, imprimir la matriz
creada.
class Matriz:
def __init__(self):
[Link] = []

def ingreseTamanio(self):
[Link] = int(input("Ingrese filas "))
[Link] = int(input("Ingrese columnas "))

def cerarMatriz(self):
for f in range([Link]):
[Link]([0] * [Link])

def ingresaDatos(self):
for f in range([Link]):
for c in range([Link]):
[Link][f][c] = int(input("elemento %d,%d: " % (f, c)))

def mostrarMatriz(self):
print("Matriz resultante...")
for f in range([Link]):
for c in range([Link]):
print([Link][f][c], end=' ')
print()

miMatriz = Matriz()
[Link]()
[Link]()
[Link]()
[Link]()

resultado:

Ingrese filas 2
Ingrese columnas 2

ING. RUBEN SANABRIA 35

 Ing. Rubén Sanabria B.
elemento 0,0: 1
elemento 0,1: 2
elemento 1,0: 3
elemento 1,1: 4
Matriz resultante...
12
34

5- Definir el tamaño de la matriz, luego ingresar los elementos de dicha matriz, sumar los elementos
entre si.
class Matriz:
def __init__(self):
[Link] = 0
[Link] = []

def definaTamanio(self):
[Link] = int(input("Ingrese filas "))
[Link] = int(input("Ingrese columnas "))

def cerarMatriz(self):
for f in range([Link]):
[Link]([0]*[Link])

def ingresaDatos(self):
for f in range([Link]):
for c in range([Link]):
[Link][f][c] = int(input("elemento %d,%d: " %(f,c)))

def calculaSuma(self):
for f in range([Link]):
for c in range([Link]):
[Link] = [Link] + [Link][f][c]
print("La suma de elementos es ",[Link])

obj = Matriz()
[Link]()
[Link]()
[Link]()
[Link]()

resultado:
Ingrese filas 2
Ingrese columnas 2
elemento 0,0: 1
elemento 0,1: 2
elemento 1,0: 3
elemento 1,1: 4
La suma de elementos es 10

Ejercicios de Estructuras estáticas-Vectores y matrices

ING. RUBEN SANABRIA 36

 Ing. Rubén Sanabria B.

1. Crear un vector cargando solo números positivos.

2. Crear un vector V de N componentes y sumar todos los elementos del vector que sean enteros.
3. Cargar un vector con elementos enteros y pares positivos.
4. Leer un vector de N componentes y luego hallar la suma y el promedio de los componentes que están en
los lugares pares y de las que se encuentran en posiciones impares.
5. Se tiene en memoria un vector B, cuyos elementos son solamente el 1 y 0 (vector binario). También se
tiene en memoria los vectores L y M, todos de tamaño N. Hacer un programa que permita crear un vector A
tal que:
1. A(x) = L(x) si B(x) = 0
2. A(x) = M(x) si B(x) = 1

6. Dado un vector de N elementos, hacer un programa que permita hallar el mayor y el menor elemento del
vector con sus posiciones respectivas.
7. Se tiene en memoria un vector A de longitud N, Hacer un programa que permita imprimir todas las
posiciones de los elementos de A que sean iguales a una X leída.
8. Hacer un programa para crear un vector V con todas las edades de los alumnos de 1er. Curso de Ing.
Informática calcular el promedio de edades.
9. Dado un vector de N elementos hacer un programa que permita hallar el mayor elemento del vector.
10. Dado un vector de N elementos hacer un programa que permita hallar el mayor y el menor elemento del
vector.
11. En cada ejercicio realiza: a) A + B b) B – A c) 2 A + 3 B d) 5 A - 4 B

ING. RUBEN SANABRIA 37