3

Consider the following minimal problem:

from math import sqrt    

class Vector(object):

    def __init__(self, x, y, z):
        self.v = [x, y, z]

    def normalize(self):
        x, y, z = self.v
        norm = sqrt(x**2 + y**2 + z**2)
        self.v = [x/norm, y/norm, z/norm]

    # other methods follow  

class NormalizedVector(Vector):

    def __init__(self, x, y, z):
        super(Vector, self).__init__(x, y, z)
        self.normalize()

So essentially NormalizedVector objects are the same as Vector objects but with the added normalization.

Would it be possible to add a method to Vector so that whenever the normalize method is called the object is automatically subclassed to NormalizedVector?

I know that I could be using the abstract factory pattern, but this would only work if objects are subclassed at creation: I would like to be able to subclass objects that have already been created previously.

I have found some solutions based on reassigning the __ class __ method, but these are discouraged. I am willing to modify the pattern above to a one that it is more "Pythonic".

Improve this question
1
  • 3
    Why not using only Vector class with a boolean normalized instance attribute? Commented Nov 19, 2015 at 12:19

3 Answers 3

Reset to default
2

I would recommend to use only the Vector() class and with a boolean normalized instance attribute.

Also, in normalize method you are using x, y and z but those variables are not defined and you are not even reading them with self.

The code I would recommend:

from math import sqrt    

class Vector(object):

    def __init__(self, x, y, z, normalized=False):
        self.v = [x, y, z]
        if normalized in [True, False]:
            self.normalized = normalized
        else:
            raise Exception("Please set normalized to either True or False")

    def __repr__(self):
        return "Vector ({}, {}, {})".format(*self.v)

    def normalize(self):
        x,y,z = self.v
        norm = sqrt(x**2 + y**2 + z**2)
        self.v = [x/norm, y/norm, z/norm]
        self.normalized = True

    def isNormalized(self):
        return self.normalized

    # other methods follow  

v1 = Vector(10, 20, 30)
print v1.isNormalized()
v1.normalize()
print v1.isNormalized()

v2 = Vector(40, 50, 60, normalized=True)
print v2.isNormalized()

Output:

False
True
True

The __repr__ function will just show a good representation of your object:

print v1

Output:

Vector (0.267261241912, 0.534522483825, 0.801783725737)
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

A vector can be initialized normalized (1,0,0), but its something up to the user of the code if that's important or not. Also, this property needs to be reset if any operation is mutating the instance.
@Caramiriel, then just (as I've updated) set a normalized kwarg with default=False and if he wants to initialize de Vector as a normalized one he could specify that in the constructor.
1

Why do you need to keep track of the normalization in the vector itself, just keep track of it in your main.py or wherever you're using the vectors?

Also, I would simply return a new copy of the object with the normalized values. This way you can create normalized vectors on the fly in your calculations without changing the original vector.

from math import sqrt    

class Vector(object):

    def __init__(self, x, y, z):
        self.v = [x, y, z]

    def normalized(self):
        x, y, z = self.v
        norm = sqrt(x**2 + y**2 + z**2)
        return Vector(x/norm, y/norm, z/norm)

If you have really many vectors you need to normalize, you can normalize them into two lists or a list of tuples or whatever you want, here's a dict example:

vectors = {}
for x, y, z in zip(range(10), range(10), range(10)):
    v = Vector(x, y, z)
    vectors[v] = v.normalize()

If you just have a few vectors or randomly need to normalize a vector for a calculation every now and then, you can just keep track of them manually or create them on the fly in the calculations without changing the original vector: v_norm = v.normalized().

Improve this answer

Comments

0

If you really want to keep the two classes you could overwrite the operations for the classes.

Let's say you want to add the vector and the normalized vector. You could do it like this

from math import sqrt

class Vector:

    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __add__(self,v):
        if isinstance(v,Vector):
            return (self.x+v.x,self.y+v.y)
        elif isinstance(v,NormVector):
            n = NormVector(self.x,self.y)
            return (n.x+v.x,n.y+v.y)

class NormVector:

    def __init__(self,x,y):
        self.x = x / sqrt(x**2 + y**2)
        self.y = y / sqrt(x**2 + y**2)

    def __add__(self,v):
        if isinstance(v,Vector):
            n = NormVector(v);
            return (self.x + n.x,self.y + n.y)
        elif isinstance(v,NormVector):
            return (self.x+v.x,self.y+v.y)


a = Vector(5,0)
b = NormVector(0,3)
c = a + b
print c

Like this you can overwrite any function you need. A list of possible operations can you find in the documentation

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.