1

I'm working on this project which deals with vectors in python. But I'm new to python and don't really know how to crack it. Here's the instruction:

"Add a constructor to the Vector class. The constructor should take a single argument. If this argument is either an int or a long or an instance of a class derived from one of these, then consider this argument to be the length of the Vector instance. In this case, construct a Vector of the specified length with each element is initialized to 0.0. If the length is negative, raise a ValueError with an appropriate message. If the argument is not considered to be the length, then if the argument is a sequence (such as a list), then initialize with vector with the length and values of the given sequence. If the argument is not used as the length of the vector and if it is not a sequence, then raise a TypeError with an appropriate message.

Next implement the __repr__ method to return a string of python code which could be used to initialize the Vector. This string of code should consist of the name of the class followed by an open parenthesis followed by the contents of the vector represented as a list followed by a close parenthesis."

I'm not sure how to do the class type checking, as well as how to initialize the vector based on the given object. Could someone please help me with this? Thanks!

Brendan Long
  • 53,280
  • 21
  • 146
  • 188
pew007
  • 441
  • 1
  • 7
  • 10
  • possible duplicate of [What is the best (idiomatic) way to check the type of a Python variable?](http://stackoverflow.com/questions/378927/what-is-the-best-idiomatic-way-to-check-the-type-of-a-python-variable) – Brendan Long Nov 24 '11 at 20:09

5 Answers5

2

Your instructor seems not to "speak Python as a native language". ;) The entire concept for the class is pretty silly; real Python programmers just use the built-in sequence types directly. But then, this sort of thing is normal for academic exercises, sadly...

Add a constructor to the Vector class.

In Python, the common "this is how you create a new object and say what it's an instance of" stuff is handled internally by default, and then the baby object is passed to the class' initialization method to make it into a "proper" instance, by setting the attributes that new instances of the class should have. We call that method __init__.

The constructor should take a single argument. If this argument is either an int or a long or an instance of a class derived from one of these

This is tested by using the builtin function isinstance. You can look it up for yourself in the documentation (or try help(isinstance) at the REPL).

In this case, construct a Vector of the specified length with each element is initialized to 0.0.

In our __init__, we generally just assign the starting values for attributes. The first parameter to __init__ is the new object we're initializing, which we usually call "self" so that people understand what we're doing. The rest of the arguments are whatever was passed when the caller requested an instance. In our case, we're always expecting exactly one argument. It might have different types and different meanings, so we should give it a generic name.

When we detect that the generic argument is an integer type with isinstance, we "construct" the vector by setting the appropriate data. We just assign to some attribute of self (call it whatever makes sense), and the value will be... well, what are you going to use to represent the vector's data internally? Hopefully you've already thought about this :)

If the length is negative, raise a ValueError with an appropriate message.

Oh, good point... we should check that before we try to construct our storage. Some of the obvious ways to do it would basically treat a negative number the same as zero. Other ways might raise an exception that we don't get to control.

If the argument is not considered to be the length, then if the argument is a sequence (such as a list), then initialize with vector with the length and values of the given sequence.

"Sequence" is a much fuzzier concept; lists and tuples and what-not don't have a "sequence" base class, so we can't easily check this with isinstance. (After all, someone could easily invent a new kind of sequence that we didn't think of). The easiest way to check if something is a sequence is to try to create an iterator for it, with the built-in iter function. This will already raise a fairly meaningful TypeError if the thing isn't iterable (try it!), so that makes the error handling easy - we just let it do its thing.

Assuming we got an iterator, we can easily create our storage: most sequence types (and I assume you have one of them in mind already, and that one is certainly included) will accept an iterator for their __init__ method and do the obvious thing of copying the sequence data.

Next implement the __repr__ method to return a string of python code which could be used to initialize the Vector. This string of code should consist of the name of the class followed by an open parenthesis followed by the contents of the vector represented as a list followed by a close parenthesis."

Hopefully this is self-explanatory. Hint: you should be able to simplify this by making use of the storage attribute's own __repr__. Also consider using string formatting to put the string together.

Karl Knechtel
  • 62,466
  • 11
  • 102
  • 153
  • -1 Please stop spreading this misinformation that Python doesn't have constructors, or that `__new__` is one. When you call `SomeClass(some, args)` in Python the system magically creates a 'blank' object, and then the `__init__` method of `SomeClass` gets control to fill in the blank object. This is **exactly** how constructors work in Java/C++; the object already exists by the time the constructor code gets control, provided by the system. The official Python docs for `__init__` even refer to it as a constructor here: http://docs.python.org/reference/datamodel.html#basic-customization – Ben Nov 24 '11 at 22:25
  • Constructors in Java and C++ cannot be explicitly called. Python's `__init__` can (although you obviously shouldn't). The definitions are subjective, and the system really does work differently. There is nothing in Python that's quite analogous to a C++ initialization list, or to Java's setting of default values for members or instance initialization blocks. I don't consider it misinformation and I find your accusation rather damaging. – Karl Knechtel Nov 24 '11 at 22:33
  • I'm not saying I think you made it up, or that you're saying so maliciously. But this idea got started somewhere and tons of very intelligent experienced Python programmers keep repeating the claim that "`__init__` is not a constructor because it doesn't create the object, only initialise it" without really thinking about it. On top of that the claim that `__new__` is a constructor is absurd; it's nothing like a Java/C++ constructor. – Ben Nov 24 '11 at 22:44
  • The other details you mention are small and obscure differences, that are irrelevant to the core concept of a constructor, and indeed you did not mention them when saying that `__init__` is not a constructor; you described `__init__` in terms that apply exactly to other language's constructors. Yes there are differences, yes it's good to point them out; but telling new Python programmers "now you mustn't confuse `__init__` with constructors from other languages, it's not a constructor" is just confusing, **especially** when the official docs **do** refer to `__init__` as a constructor. – Ben Nov 24 '11 at 22:46
  • 2
    On further reflection, there is nothing that I can really accomplish with my argument, so I've removed the offending sentences. – Karl Knechtel Nov 24 '11 at 23:40
  • Thanks. The rest of your answer is excellent; -1 replaced with +1 – Ben Nov 24 '11 at 23:53
0

Everything you need to get started is here: http://docs.python.org/library/functions.html

John Zwinck
  • 239,568
  • 38
  • 324
  • 436
0

There are many examples of how to check types in Python on StackOverflow (see my comment for the top-rated one).

To initialize a class, use the __init__ method:

class Vector(object):
    def __init__(self, sequence):
        self._internal_list = list(sequence)

Now you can call:

my_vector = Vector([1, 2, 3])

And inside other functions in Vector, you can refer to self._internal_list. I put _ before the variable name to indicate that it shouldn't be changed from outside the class.

The documentation for the list function may be useful for you.

Brendan Long
  • 53,280
  • 21
  • 146
  • 188
  • Thanks for the quick reply! it works for the sequences, but how about when the parameter is an int or a long (like Vector(3)), then the result should be Vector([0.0,0.0,0.0])? – pew007 Nov 24 '11 at 21:05
  • @pew007 - Take a look at the link I added as a comment for how to tell the difference between the types. – Brendan Long Nov 24 '11 at 21:17
0

You can do the type checking with isinstance.

The initialization of a class with done with an __init__ method.

Good luck with your assignment :-)

Raymond Hettinger
  • 216,523
  • 63
  • 388
  • 485
0

This may or may not be appropriate depending on the homework, but in Python programming it's not very usual to explicitly check the type of an argument and change the behaviour based on that. It's more normal to just try to use the features you expect it to have (possibly catching exceptions if necessary to fall back to other options).

In this particular example, a normal Python programmer implementing a Vector that needed to work this way would try using the argument as if it were an integer/long (hint: what happens if you multiply a list by an integer?) to initialize the Vector and if that throws an exception try using it as if it were a sequence, and if that failed as well then you can throw a TypeError.

The reason for doing this is that it leaves your class open to working with other objects types people come up with later that aren't integers or sequences but work like them. In particular it's very difficult to comprehensively check whether something is a "sequence", because user-defined classes that can be used as sequences don't have to be instances of any common type you can check. The Vector class itself is quite a good candidate for using to initialize a Vector, for example!

But I'm not sure if this is the answer your teacher is expecting. If you haven't learned about exception handling yet, then you're almost certainly not meant to use this approach so please ignore my post. Good luck with your learning!

Ben
  • 68,572
  • 20
  • 126
  • 174