# -*- coding: utf-8 -*-

"""
Created on Sun Dec 1 17:34:43 2024

@author: Ruben
"""

#print ('Hola Mundo')

#print ("Hola a todos")

#Tipos de datos:
#Numericos
#Texto
#Booleanos

#Tipos Numericos:

#(nota: no es key sensitive, ejemplo: )

edad = 12
Edad = 13.12
eDad = 14
#tampoco especifico el tipo de dato, lo hace dinamicamente Python.

#
EDAD = 13.2
EDAD = 13
#EDAD queda con el ultimo tipo de dato asignado en este caso un INT.
altura = 1.73
print(EDAD, altura)

#funcion type para identificar/saber/verificar el tipo de dato:

print( type(EDAD), type(altura) )

#operandos u operadores aritméticos en orden(de últimos a primeros) :

#-substracción, + suma, * multiplicación, / o // división,
#% residuo, - negación, ** exponenciación

a = 5
b = 2

print(a-b)
print(a+b)
print(a*b)
print(a/b) #toma en cuenta los decimales
print(a//b) # no toma en cuenta los decimales
print(a%b)
print(-a)
print(-b)
print(a**b) # 5 al cuadrado
print(b**a) # 2 elevado a la 5
print( a + b*a )
print( (a+b) * a) #fuerzo el orden de precedencia utilizando los parentesis
#los parantesis me permiten indicar un orden de precedencia diferente.

#Tipos de datos, Texto:

nombre = "Ruben"
#nombre[0] => "R"
apellido = "Lezcano"

#concatenación con el simbolo + entre strings

print (nombre, apellido)
print (nombre + apellido)

#funciones básicas de cadenas:

#len() , str(), int(), float()
print( len(nombre) )
print(str(390)) #int to string conversion 390 pasa a ser "390"
print(int("9811")) # string to int conversion "9811" pasa a ser 9811
print(float("9012.2")) #string to float conversion "9012.2" a 9012.2

#como hacer un comentario de multiples lineas:

"""
hola soy un comentario de multiple lineas
y lalalal
kkekekkek xdd
"""

"""Console => restart kernel | Terminales => Reiniciar el núcleo

lo que hace es reiniciar el Explorador de variables y la terminal
y toma de nuevo las variables que estan en el código, exceptuando
las variables comentadas"""

#se puede multiplicar un string y se repite la cantidad de veces indicada:

print(nombre*3) #muestra Ruben(o la variable nombre) 3 veces
print(nombre[len(nombre) - 1]) # imprime la ultima letra de la variable nombre
#otras funciones: .lower(), .upper(), index(), capitalize(), strip(), replace(),
[inicio: final]
print(nombre[0:3]) #trae Rub (el 3 no esta incluido, iria desde el 0 al 2), tambien
puedo obviar el 0 haciendo [:3]
print(nombre[3:len(nombre)])#en
print(nombre[-2:]) #toma los dos ultimos elementos
#capitalize() solamente te pone en mayuscula la primera letra del string
#strip() quita los espacios del principio y final del string
#replace("r", "F") reemplaza las r por F
#index("e") devuelve el indice de la primera aparicion del texto que yo estaba
buscando

#
22222222222222222222222222222222222222222222222222222222222222222222222222222222222
2

#condicional if
artes = False
deportes = False
matematicas = True

if artes == True:
print("estudia Teatro")
#la identacion o espacio despues del if es OBLIGATORIA en Python para especificar
que esa linea va dentro del if
if artes == True:
print('estudia teatro')
else:
print ("podrias estudiar medicina o ingenieria")

#otra forma resumida:

if artes:
print('estudia teatro')
elif deportes: #else if
print ("podrias estudia medicina deportiva")
elif matematicas: #else if
print ("podrias estudia matematicas")
else:
print ("consulta a un asesor vocacional")

if artes and matematicas:

print("artes y matematicass")

if artes and not matematicas:

print("eeeeeeeeeeeee")

#entrada = input("Introduce tu edad: ") #pide ingreso de datos por consola

#entrada = int(entrada)

#
3333333333333333333333333333333333333333333333333333333333333333333333333333333333

"""Listas, sum(), max(), min(), insert(posicionAInsertar, valor), append(valor) (lo

agrega al final)
extend([32,10 ]) (añade una lista a otra)
remove(50) (borra la primer coincidencia del valor en la lista.
pop() borra el ultimo valor de la lista
count(valor) busca las coincidencias en la lista y devuelve la cantidad de las
mismas
lista.sort() ordena de menor a mayor
lista.sort(reverse=True) o tambien lista.reverse() de mayor a menor

"""
edades = [13,35,2,14324]
persona1 = ["Ruben", 12]
items = [edades, persona1]

print(items[1])

print(items[0])
print(items[1][0])
print(items[0][3])

#
4444444444444444444444444444444444444444444444444444444444444444444444444444444444

#CONJUNTOS/SETS (no se repiten los elementos):

nombres2020= {"ruben", "dario", "maxi","ruben"}
nombres2021= {"jose", "carlos", "maxi"}
print("Muestra de que no se pueden ingresar repetidos en un CONJUNTO: ",
nombres2020) #se imprimen 3 y se saca el repetido #si usamos.add("ruben") tampoco
se añade

nombres_unidos = nombres2020.union(nombres2021) #une las listas

print( "UNION: ", nombres_unidos )

print("INTERSECCION: " , nombres2020.intersection(nombres2021)) #muestra los

coincidentes entre ambos CONJUNTOS.
print("DIFERENCIA: ", nombres2020.difference(nombres2021)) #muestra los que NO
coinciden del primer conjunto con el segundo

#verificar si un conjunto esta dentro de otro conjunto(A es un subconjunto de B)

#si los nombres del 2020 se encuentran contenidos dentro de todos los nombres
nombres2020.issubset(nombres_unidos)

#superconjunto si un conjunto contiene a otro conjunto

#si nombres_unidos es un super conjunto de nombres2020 es decir si los nombres2020
es un subconjunto
#de todos los nombres.
nombres_unidos.issuperset(nombres2020)

#
55555555555555555555555555555555555555555555555555555555555555555555555555555555555
5

#TUPLAS (diferencias con las listas, es que las tuplas son elementos inmutables(no
se puede
#borrar ni quitar elementos))

#listas => flexibilidad pero menos eficiencia

#tuplas => eficiencia pero menos flexibilidad

tupla = ("Dario", 22)

#tupla[0] = 1 #acá marca error por que no se puede modificar

#no se puede modificar la tupla sin embargo podemos convertirla en lista :

lista=list(tupla)
lista[0]="DarioR"
print(lista)

#tambien se puede convertir una lista en tupla:

una_tupla=tuple(lista)
print(una_tupla)
#tambien se puede convertir una tupla en un conjunto:
conjunto=set(una_tupla)
print(conjunto)
"""
['DarioR', 22] lista se muestra con corchetes
('DarioR', 22) tupla se muestra con parentesis
{'DarioR', 22} conjunto se muestra con llaves
"""

#
66666666666666666666666666666666666666666666666666666666666666666666666666666666666
66

contador=0
contador_negativos=0
while contador < 10:
print("Iteración: ", contador)
contador+=1 #contador = contador + 1
print("Iteración: ", contador_negativos)
contador_negativos-=1 #contador_negativos = contador_negativos - 1
print("Termina ejecución") #se debe respetar la identación

total=0
num_sumas=5
contador_=0

while contador_ < num_sumas:

num = int(input("Ingresa un número: "))
total = total + num
contador_ +=1

print("El total de la suma es: ", total)

"""

for numero in [0,1,2,3,4,5,6,7,8,9]:

print("Iteración: ", numero)

# Tienda de pinturas

colores = ["rojo", "verde","amarillo","azul"]

#con FOR
for color in colores:
print("FOR => Hay pintura color:", color)

#con WHILE
indice = 0
while indice < len(colores):
print("WHILE => Hay pintura color:", colores[indice])
indice += 1

for numero in range(5,11): #range() genera una lista de un valor determinado a

partir del
#0 hasta el que indiquemos, range(5,11) genera una lista del 5 al 11
print("Iteración:", numero)
"""
#
77777777777777777777777777777777777777777777777777777777777777777777777777777777777
777
#Funciones

def suma_dos_numeros(a, b):

suma= a+b
return suma

print("El resultado de la suma es:", suma_dos_numeros(3,2))

def suma_numero_indeterminado_numeros(*numeros): #el asterisco indica que lo que

siga va a ser un identificador del tipo tuplaque va a tener un numero indeterminado
de elementos
# numeros = (1,2,3,4,5, infinitos)
suma= 0
for numero in numeros:
suma = suma + numero
return suma

print("Suma:", suma_numero_indeterminado_numeros(3,27,12)) #suma 3 numeros

print("Suma:", suma_numero_indeterminado_numeros(3,27,12,8,9,100)) #suma 6 numeros

def formatea_nombre(nombre, apellido, apellido_materno=""): #="" indica que el

parametro es opcional
return nombre.upper() + " " + apellido.capitalize() + " " +
apellido_materno.capitalize()

print(formatea_nombre("rubEn", "LEZCANo", "sanCHEz"))

print(formatea_nombre("malena", "ponTI"))

#si yo especifico los parametros puedo ponerlos en el orden que yo quiera.

print(formatea_nombre(apellido="LagarDE", apellido_materno="PoNtI",
nombre="alVaro"))

#
88888888888888888888888888888888888888888888888888888888888888888888888888888888888

def doblar(referencia, valor):

referencia *= 2
valor *=2
print("DURANTE:", referencia, valor)

estructura = ["a","b","c"] #estructura de datos #se manda la direccion de memoria

de la variable y se modifica la misma
primitiva = "abc" #variable primitiva string #se crea una copia al pasarla por
parametro

print("ANTES:", estructura, primitiva)

doblar(estructura, primitiva)
print("DESPUES:", estructura, primitiva )

#
99999999999999999999999999999999999999999999999999999999999999999999999999999999999
99
externa = "EXTERNA"

def funcion(parametro):
interna = "INTERNA"
print("ADENTRO", externa, parametro, interna)

funcion("PARAMETRO_")

print("AFUERA", externa, interna, parametro)

#
10000000000000000000000000000000000000000000000000000000000000000000000000000000000
00
una funcion con una sola expresion de una linea, si yo quisiera mas lineas deberia
usar
una funcion tradicional
"""
#los dos puntos indican la finalizacion de los parametros
suma = lambda a, b : a + b
multiplicacion = lambda a,b,c : a*b*c
constante = lambda: 10 #devuelve una constante en este caso 10

print(suma(2,7), multiplicacion(1,9,6), constante())

personas = [("Juan",82,5),("Luisa",41,10),("Arnulfo",75,20)]

print("Desordenada", personas)
personas.sort() #esto ordena por defecto por el primer elemento de cada
iteracion(en este caso
#por tipo de dato tupla) y por nombre
print("Ordenada por nombre", personas)
personas.sort(key= lambda persona: persona[1]) # esto le indica que ordene por el
segundo elemento
print("Ordenada por edad", personas)
personas.sort(key= lambda persona: persona[1] + persona[2]) # esto le indica que
ordene por la suma de dos elementos
print("Ordenada por edad+credito", personas)

#lo mismo pero de mayor a menor

personas.sort(key= lambda persona: persona[1] + persona[2], reverse=True) # esto le
indica que ordene por la suma de dos elementos
print("Ordenada por edad+credito", personas)

#las funciones lambdas se usan en combinacion con Pandas una libreria de analisis
de datos
#para realizar filtros
"""

#
11111111111111111111111111111111111111111111111111111111111111111111111111111111111
"""
PERSONA

LLAVES: nombre, edad direccion, altura, peso

VALORES: Ruben, 33, Paraguay 1856, 1.81, 108
"""

persona = { "nombre": "Ruben", "edad": 37, "direccion": "Paraguay 1856"}

print(persona["nombre"]) #acceder al valor

print(persona.get("nombre")) #acceder al valor

for llaves in persona.keys():

print(llaves)
#me da estos resultados:
#nombre
#edad
#direccion

for elemento in persona.items():

print(elemento)
#salida:
#('nombre', 'Ruben')
#('edad', 37)
#('direccion', 'Paraguay 1856')

for llave, valor in persona.items():

print(llave, valor)
#salida:
#nombre Ruben
#edad 37
#direccion Paraguay 1856

#actualizar valor en un diccionario:

persona["direccion"] = "Av. Hipolito Yrygoyen 2959"

#actualizar MULTIPLES elementos/llaves

persona.update({"direccion": "no se donde me mudaré xd", "altura": 1.83}) #tambien
se añade llave altura

#añadir llave
persona["peso"] = 108
print(persona)

#quitar llave
persona.pop("peso")
print(persona)

"""conteo de palabras(lo usan en redes sociales para ver si mencionas mucho una
palabra te asocian algo
por ejemplo si decis mucho amor pueden decir que sos romantico) """

texto = "texto agregado gdLorem ipsum dolor sit amet, consectetur adipiscing elit,
sed texto agregado do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Ut enim ad minim veniam, quis nostrud texto exercitation ullamco laboris nisi ut
aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in
voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
est laborum."

simbolos_a_quitar = (",",".") #voy a quitar comas, puntos

for simbolo in simbolos_a_quitar:

texto = texto.replace(simbolo, "")
print(texto)

#cambio el texto a mayuscula para que mi programa no diferencie entre mayusculas y

minusculas
texto = texto.upper()

vocablos = texto.split() #genera una lista, con un elemento por cada una de las
palabras tomando el espacio por separador
#otra manera: texto.split(" ")
palabras = {}

for vocablo in vocablos:

if(vocablo in palabras.keys()):
palabras[vocablo] = palabras[vocablo] + 1
else: palabras[vocablo] = 1

print(palabras.keys())
print(palabras.values())
print(palabras.items())

for llaves, valores in palabras.items():

print(llaves, valores)
#y aca tenemos un listado de diccionarios con la cantidad
#de apariciones de cada palabra.

#un diccionario tiene un orden predeterminado no se puede

#ordenar con .sort() por ejemplo, pero podemos convertir
#el diccionario en una lista y ordenarla.

lista = list(palabras.items())
print(lista)
lista.sort(key= lambda palabra : palabra[1],reverse=True)

print(lista)

#1111112222222222222222222222222222222222222222222222222222222222222222222222222

try:
monto = float(input("Indica el monto del crédito: "))
num_pagos = float(input("Indica el número de pagos: "))
pago_mensual = monto/num_pagos
print("El pago mensual será de:", pago_mensual)
except ValueError: #tambien puedo escribir Exception
 print("Captura valores numéricos") #estos son tips al usuario de como debe
usar nuestro programa
except ZeroDivisionError:
print("No puedes indicar 0 pagos") #por que no se puede dividir por cero
except:
#excepción general(en caso de que haya cualquier excepción viene por acá)
print("Hubo un error, por favor intentalo nuevamente")

#versión con excepciones custom y (CASI) custom xd

#por si el usuario ingresa numeros negativos
try:
monto = float(input("Indica el monto del crédito: "))
num_pagos = float(input("Indica el número de pagos: "))
if num_pagos < 0 :
raise Exception("Ingresa valores positivos para el número de pagos")
elif num_pagos > 12:
raise Exception("Tienes que pagar en 12 meses o menos")
pago_mensual = monto / num_pagos
print("El pago mensual será de:", pago_mensual)
except ValueError:
#tambien puedo escribir Exception
print("Captura valores numéricos") #estos son tips al usuario de como debe
usar nuestro programa
except ZeroDivisionError:
print("No puedes indicar 0 pagos") #por que no se puede dividir por cero
except Exception as un_error:
print(un_error) #output: Ingresa valores positivos para el número de pagos
print(un_error.args) #output: ('Ingresa valores positivos para el número de
pagos',)
print(un_error.args[0]) #output: Ingresa valores positivos para el número
de pagos

else: #se ejecuta si no pasó por ninguna excepción

print("La solicitud de tu crédito se ha realizado exitosamente")
finally: #se ejecuta siempre
print("Gracias por su preferencia")

#
11111111111114444444444444444444444444444444444444444444444444444444444444444444444
#chequear los modulos instalados, tipeamos en la terminal help("modules")

import math as m (alias para math es ahora m)

#help(m)
#nos va a dar un listado de variables y constantes que estan definidas dentro
#del modulo math

print(m.ceil(2.1)) #redondea hacia arriba

print(m.floor(2.1)) #redondea hacia abajo

#supongamos que del modulo math solo me interesa usar ciertas funciones, entonces
puedo
#hacer que me importe del modulo las librerias que quiero
"""
#aca solo importamos las funciones y no es necesario utilizar el math.funcion()
#sino solo funcion()
from math import floor, ceil

print(floor(2.5))
print(ceil(2.5))

#importa todas las funciones y seguimos sin utilizar el math.funcion()

from Modulos.Manejo_Archivos import leer, escribir

escribir("Modulos/archivito.txt", "este es un texto secreto :P")

print(leer("Modulos/archivito.txt"))

"""

#
1111111111111111111111155555555555555555555555555555555555555555555555555555555555

"""
CASO BASE: El caso más simple o el último caso

CASO RECURSIVO: La función se llama a sí misma, pero resolviendo

un problema menor.
"""

"""
imprimir numeros del 5 al 0

primero necesito
Imprimir 5 + Imprimir del 4 al 0
Imprimir 4 + Imprimir del 3 al 0
Imprimir 3 + Imprimir del 2 al 0
Imprimir 2 + Imprimir del 1 al 0
Imprimir 1 + Imprimir el 0

"""

def recursiva(n):
if n == 0:
print(n)
else:
print(n)
recursiva(n-1)

recursiva(5)

"""
ejemplo de calculo del factorial
al factorial lo especificamos con el simbolo de exclamación

0! = = 1
1! = 1 = 1
2! = 1 * 2 = 2
3! = 1 * 2 * 3 = 6
4! = 1 * 2 * 3 * 4 = 24
5! = 1 * 2 * 3 * 4 * 5 = 120

"""

print("empieza factorial hecho por Ruben")

#mi metodo sin ver el ejemplo:

def factorial(n, result = 1):
if n == 0 or n == 1:
if result > 1:
print(result)
else:
print(1)
else:
factorial(n-1, n * result )

factorial(6)

#metodos del profe:

print("empieza factoriales hechos por el profe")
def factorial_iterativo(n):
if n == 0 or n == 1:
return 1
resultado = 1
for i in range(2, n + 1 ):
resultado *= i
return resultado

print("factorial iterativo ")

for i in range(6):
print(i, factorial_iterativo(i))

factorial_iterativo(5)

print("factorial recursivo ")

def factorial_recursivo(n):
if n == 0 or n == 1: #Caso base
return 1
return n * factorial_recursivo( n - 1 ) #Caso recursivo

for i in range(6):
print(i, factorial_recursivo(i))

print("factorial iterativo y recursivo: ")

for i in range(6):
print(i, factorial_iterativo(i), factorial_recursivo(i))

#La función recursiva es mucho más lenta que la función iterativa

#medir los tiempos de ejecución:

from time import perf_counter

inicio = perf_counter()
for i in range(1000000):
 factorial_iterativo(100)
fin = perf_counter()

#% indica que es un valor y 0.4 que tiene 4 decimales y f que es float

#el segundo% castea a float(creo xd)
print("Iterativo %0.4f" % (fin-inicio))

inicio = perf_counter()
for i in range(1000000):
factorial_recursivo(100)
fin = perf_counter()

print("Recursivo %0.4f" % (fin-inicio))

#como se puede apreciar el metodo recursivo lleva un poco más del doble de tiempo
#de ejecución que el metodo iterativo

# 11111111111111116666666666666666666666666666666666666666666666666666666666666666

def busqueda_binaria_iterativa(lista, dato):

bajo = 0
alto = len(lista) - 1
centro = (bajo + alto) // 2
while bajo <= alto:
if lista[centro] == dato:
return centro
elif lista[centro] < dato:
bajo = centro + 1
else:
alto = centro - 1
centro = (bajo + alto)//2
return -1

lista = [11,12,13,14,15,16,17]

def busqueda_binaria_recursiva(lista, bajo, alto, dato):

if bajo > alto:
return -1
centro = (bajo + alto) // 2
if lista[centro] == dato:
return centro
elif lista[centro] < dato:
return busqueda_binaria_recursiva(lista, centro + 1, alto, dato)
else:
return busqueda_binaria_recursiva(lista, bajo, centro -1, dato)

for i in range(10,19):
print(i, busqueda_binaria_iterativa(lista, i))
print(i, busqueda_binaria_recursiva(lista, 0, len(lista) -1 , i))

# 111111111111111111111111111117777777777777777777777777777777777777777777777777
from random import randint

class Tragamonedas:

def __init__(self, id, premio):

self.id = id
self.premio = premio
self.monedas = 0
self.jackpots = 0

def __str__(self):
return "Id: "+ str(self.id) + " - Premio: " + str(self.premio)

def __eq__(self, otro):

return self.monedas == otro.monedas

def __lt__(self, otro):

return self.monedas < otro.monedas

def __gt__(self, otro):

return self.monedas > otro.monedas

def jugar(self):
self.monedas += 1
numeros = randint(0, 9), randint(0, 9), randint(0, 9)
mensaje = ""
if numeros[0] == numeros[1] == numeros[2]:
self.jackpots += 1
mensaje = "Felicidades !!! Ganaste %0.2f" % self.premio
else:
mensaje = "Mejor suerte para la próxima"
return numeros, mensaje

tragamonedas_a = Tragamonedas(1, 1000)

tragamonedas_b = Tragamonedas(1, 1000)

for i in range(100):
print(tragamonedas_a.jugar())
print(tragamonedas_b.jugar())

# 1111111111111111111888888888888888888888888888888888888888888888888888888888888

class Cuenta:

def __init__(self, nombre, direccion):

self.nombre = nombre
self.direccion = direccion
self.__balance = 0.00

def retirar(self, monto):

if self.__balance >= monto:
self.__balance -= monto
 def depositar(self, monto):
if monto > 0:
self.__balance += monto

def metodosindefinir(self, monto):

pass

def __ejemplometodoprivado(self,monto):
return ""

#"TRUQUITO" de python para acceder al valor privado de una clase desde afuera de la
misma:
#nombreInstancia.NombreClase__propiedad.
#Ejemplo: cuenta.Cuenta__balance

# 111111111111111111111111199999999999999999999999999999999999999999999999999999
class Vehiculo:

folio = 0
COLORES = ("BLANCO", "ROJO", "VERDE")

def __init__(self, color):

Vehiculo.folio += 1
self.serie = Vehiculo.folio
self.set_color(color)

def __str__(self):
return str(self.serie) + " " + self.color

def set_color(self, color):

color = color.upper().strip()
if color in Vehiculo.COLORES:
self.color = color
else:
self.color = Vehiculo.COLORES[0] #default

vehiculo_a = Vehiculo("Rojo ")

vehiculo_b = Vehiculo(" Azul")

print(vehiculo_a)
print(vehiculo_b)

# 22222222222222222222222222222220000000000000000000000000000000000000

class Producto:

def __init__(self, id, descripcion, costo):

self.id = id
self.descripcion = descripcion
self.costo = costo

def crear_etiqueta(self):
return " %s \n %s \n %0.2f" % (self.id,
self.descripcion,
 self.costo)

class Electronico(Producto):

def __init__(self, id, descripcion, costo, marca):

super().__init__(id, descripcion, costo)
self.marca = marca

class Perecedero(Producto):

def __init__(self, id, descripcion, costo, caducidad):

super().__init__(id, descripcion, costo)
self.caducidad = caducidad

def crear_etiqueta(self):
return super().crear_etiqueta()+ "\n %s" % self.caducidad
#aca se hace una especializacion de crear etiqueta... yo podria crearme un
metodo
#con otro nombre en lugar de sobreescribirlo(usar el mismo nombre que clase
padre)
#pero asi tendria este nuevo metodo y tambien el crear_etiqueta de la clase
padre
#y tener los dos metodos seria algo confuso y estariamos en un mal diseño

productos = (Producto("g", "Producto", 100),

Perecedero("p", "Tomates", 200, "01/01/2022"),
Electronico("e", "Electrónico 1", 300, "Sony"))

for objeto in productos:

print ("*****")
print (objeto.crear_etiqueta())

"""
isintance(per, Producto) => True
isintance(ele, Producto) => True
isintance(pro, Producto) => True

isintance(pro, Electronico) => False

isintance(pro, Perecedero) => False
isintance(pro, Producto) => True
isintance(per, Perecedero) => True

"""

#Nota: en Python no se requiere herencia para hacer polimorfismo

#pero esto no quiere decir que no necesitamos la herencia, ya que posee varios
#ventajas/beneficios.(no repetir código, etc)

#Polimorfismo: es la capacidad de un objeto de comportarse, de adoptar diferentes

formas