Notebook

Reto 1¶

Cree una clase llamada Punto3D para puntos en el espacio tridimensional, con sus tres coordenadas x, y, z.

Implemente el método constructor para crear puntos fácilmente. Si no se recibe una coordenada, su valor será cero.
Sobrescriba el método string __str__, para que al imprimir por pantalla un punto aparezca en formato (x,y,z).
Implemente el método vector, que toma otro punto y calcula el vector resultante entre los dos puntos.
Implemente el método distancia, que toma otro punto y calcule la distancia entre ambos puntos.

Solución¶

En el espacio tridimensional, dados dos puntos P y Q de coordenadas

$$P=(p_1,p_2,p_3)$$$$Q=(q_1,q_2,q_3)$$

podemos calcular el vector PQ que va entre ambos, con origen en P y final en Q, restando sus componentes de la siguiente forma: $$PQ = Q-P = (q_1,q_2,q_3) - (p_1,p_2,p_3) = (q_1-p_1,q_2-p_2,q_3-p_3)$$

La distancia entre dos puntos es su norma y se calcula como la raiz cuadrada de la diferencia de componentes al cuadrado. $$|PQ| = |QP| = \sqrt{(q_1-p_1)²+(q_2-p_2)²+(q_3-p_3)²}$$

In [1]:

import math

class Punto3D:
    def __init__(self, x=0, y=0, z=0):
        self.x = x
        self.y = y
        self.z = z
    def __str__(self):
        return f"({self.x},{self.y},{self.z})"
    def vector(self,q):
        return f"El vector entre {self} y {q} es ({q.x-self.x},{q.y-self.y},{q.z-self.z})"
    def distancia(self,q):
        return f"La distancia entre {self} y {q} es {math.sqrt((q.x-self.x)**2+(q.y-self.y)**2+(q.z-self.z)**2)}"

p = Punto3D(1,2,3)
q = Punto3D(3,5,8)
print("Punto p:",p)
print("Punto q:",q)
print(p.vector(q))
print(q.vector(p))
print(p.distancia(q))
print(q.distancia(p))                                                             

Punto p: (1,2,3)
Punto q: (3,5,8)
El vector entre (1,2,3) y (3,5,8) es (2,3,5)
El vector entre (3,5,8) y (1,2,3) es (-2,-3,-5)
La distancia entre (1,2,3) y (3,5,8) es 6.164414002968976
La distancia entre (3,5,8) y (1,2,3) es 6.164414002968976

Reto 2¶

Crear una función que diga en que cuadrante está un punto del plano definido por sus coordenadas cartesianas (x,y).

In [5]:

def cuadrante(x,y):
    if x > 0 and y > 0: return "Primer cuadrante."
    elif x < 0 and y > 0: return "Segundo cuadrante."
    elif x < 0 and y < 0: return "Tercer cuadrante."
    elif x > 0 and y < 0: return "Cuarto cuadrante."
    else: return "Origen."

x,y = 3,4
print(f"Punto ({x},{y}) esta en el {cuadrante(x,y)}")

x,y = -2,5
print(f"Punto ({x},{y}) esta en el {cuadrante(x,y)}")

x,y = -1,-1
print(f"Punto ({x},{y}) esta en el {cuadrante(x,y)}")

x,y = 3,-6
print(f"Punto ({x},{y}) esta en el {cuadrante(x,y)}")

x,y = 0,0
print(f"Punto ({x},{y}) esta en el {cuadrante(x,y)}")

Punto (3,4) esta en el Primer cuadrante.
Punto (-2,5) esta en el Segundo cuadrante.
Punto (-1,-1) esta en el Tercer cuadrante.
Punto (3,-6) esta en el Cuarto cuadrante.
Punto (0,0) esta en el Origen.

Reto 3 Herencia¶

Crear la clase Punto

El punto viene expresado por sus coordenadas (x,y) en el plano cartesiano
Si no se reciben coordenadas el contructor les asigna el origen

Crear la clase Triangulo que hereda de la clase Punto

Un triángulo en el plano viene definido por sus tres vértices
Crear un método que calcule el área del triángulo

In [4]:

class Punto():
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

class Triangulo(Punto):   # la clase Triangulo hereda de la clase Punto, se pone dentro del paréntesis
    def __init__(self, a=Punto(), b=Punto(), c=Punto()):
        self.a = a
        self.b = b
        self.c = c
    def area(self):
        return abs(self.a.x * self.b.y +
                   self.b.x * self.c.y +
                   self.c.x * self.a.y -
                   self.a.x * self.c.y -
                   self.c.x * self.b.y -
                   self.b.x * self.a.y) / 2.0

a = Punto()
b = Punto(10,0)
c = Punto(5,20)
tri = Triangulo(a,b,c)
tri.area()

Out[4]:

100.0