Crear abstracciones — Python: Abstracción con datos

• Sistema de Coordenadas Polares
  • Conversión entre sistemas de coordenadas
• Ocultar la estructura interna
  • Cambiar la representación interna**

Cuando trabajamos con coordenadas, usualmente pensamos en el sistema cartesiano con ejes X e Y. Sin embargo, existe otro sistema llamado coordenadas polares, que puede facilitar ciertos cálculos y representaciones gráficas.

En esta lección exploraremos qué es la coordenada polar, cuándo es útil y cómo podemos usar la abstracción de datos para hacer nuestro código más flexible y mantenible.

Sistema de Coordenadas Polares

En el sistema cartesiano, una posición en el plano se define con dos valores: (x, y), que indican desplazamientos en las direcciones horizontal y vertical.

En el sistema polar, en lugar de usar X e Y, utilizamos:

• Radio (r): distancia desde el origen hasta la ubicación deseada
  
• Ángulo (φ): medida del giro desde el eje positivo X hasta la línea que conecta el origen con la ubicación, expresado en grados (0° a 360°) o radianes (0 a 2π)

⏬ Ejemplo de Coordenadas Polares

Imagina que tenemos un punto P representado así en coordenadas polares:

P(5, 60°)

Aquí:

• El radio r = 5 indica que el punto está a 5 unidades del origen
  
• El ángulo φ = 60° nos dice que se encuentra girado 60° desde el eje X positivo
  

Representación gráfica:

Conversión entre sistemas de coordenadas

Si queremos convertir de polares a cartesianas, usamos las fórmulas:

\[ x = r \cdot \cos(φ) \] \[ y = r \cdot \sin(φ) \]

Para nuestro ejemplo con P(5, 60°):

\[ x = 5 \cdot \cos(60°) = 5 \cdot 0.5 = 2.5 \] \[ y = 5 \cdot \sin(60°) = 5 \cdot 0.866 = 4.33 \]

Así, en coordenadas cartesianas, este punto es aproximadamente P(2.5, 4.33).

Ocultar la estructura interna

Ahora que entendemos cómo podemos representar puntos de manera diferente, imaginemos que estamos desarrollando un software de gráficos y queremos que funcione tanto con coordenadas cartesianas como polares.

El problema es que nuestra biblioteca solo entiende coordenadas cartesianas, y usar polares requeriría cambiar mucho código. Si el código accede directamente a los datos (x, y) en cada parte del programa, cualquier modificación sería costosa.

Para evitar este problema, podemos ocultar los detalles internos de cómo representamos un punto mediante funciones:

def make_point(x, y):
    return {"x": x, "y": y}

def get_x(point):
    return point["x"]

def get_y(point):
    return point["y"]

Ahora, en lugar de acceder directamente a las estructuras de datos, usamos estas funciones:

# Sin abstracción (malo)
point = [2, 3]
print(point[0])  # Acceso directo a la lista

# Con abstracción (bueno)
point = make_point(2, 3)
print(get_x(point))  # Acceso solo a través de la función

Este enfoque genera abstracción de datos, lo que significa que podemos cambiar la estructura interna sin modificar el código que usa los puntos.

Cambiar la representación interna**

Por ejemplo, supongamos que queremos representar los puntos internamente en coordenadas polares en lugar de cartesianas:

import math

def make_point(x, y):
    return {
        "angle": math.atan2(y, x),  # Convierte a radianes
        "radius": math.sqrt(x ** 2 + y ** 2)
    }

Ahora, los datos se almacenan en coordenadas polares, pero el resto del programa sigue funcionando sin cambios, porque las funciones de acceso no han cambiado.

Este enfoque es útil cuando queremos cambiar la representación interna de nuestros datos sin modificar todo el código externo que los utiliza.