Christian Calderon wrote: > I have been using python for 4 years now, and I just started learning > ruby. I like that in ruby I don't have to type parenthesis at the end of > each function call if I don't need to provide extra arguments.
That's one of the things which I dislike most about Ruby. Python has a nice, clean design: obj.method returns the method object, x() on any object calls it. (Possibly not successfully, if it is not a type, function or method, but it makes the attempt.) Making the parentheses optional just confuses the two, just for the sake of saving a couple of keystrokes. > I just > realized right now that I can do something similar in python, if I make > all methods with only the implicitly passed 'self' into properties. I wouldn't expect that there should be very many of such methods (except in, say, a type like str, where you have a bunch of transformation methods like str.upper() etc. -- but they shouldn't be treated as properties at all). A plethora of argument-less methods is a code smell -- that doesn't mean it's *necessarily* a bad idea, but the class design really needs a careful review. The problem with argument-less methods is that things which should be temporary arguments are being stored as permanent state instead. E.g. if you're calling methods just for their side-effect of setting up a bunch of attributes, just so you can then do what you really want which is call another method, that's a bad design which should be refactored to pass arguments direct to the method: # Bad class SandwichMaker: def prepare_sandwich_ingredients(self, bread, butter, fillings, openface=False): self._bread = bread self.butter = butter self.fillings = fillings self.openface = openface def make_sandwich(self): base = self.bread if not self.openface: cover = self.bread else: cover = None if self.butter in ('butter', 'margarine', 'mayo'): base += self.butter if cover: cover += self.butter for filling in self.fillings: self.thing_to_get = filling base += self.get_ingredient() if cover: # butter goes on the inside, not the top self.thing_to_flip = cover self.flip_the_thing_that_needs_flipping() base += self.thing_to_flip return base Obviously this is a fanciful example, but I've seen too much real code where too many methods existed solely to stuff data into an attribute so another method could get to it, after which that attribute was unneeded. It's the OOP equivalent of writing functions which communicate only by global variable. > Which > means I can either do some fancy coding and make a metaclass that does > this auto-magically, or I have to have property decorators all over the > place > :-P . I was wondering what other thought of this, is it an overly fanciful > way of coding python, or is it an acceptable thing to do in a real > project? Also, would anyone be interested in helping me make this > metaclass? Personally, I think it's a horrible idea, but if you must do it, I'd suggest doing it with a class decorator, not a metaclass. Something like this: # Untested. def make_zero_arg_methods_into_properties(cls): for name, obj in vars(cls).items(): if inspect.isfunction(obj): if inspect.getargspec(obj) == (['self'], None, None, ()): setattr(cls, name, property(obj)) return cls @make_zero_arg_methods_into_properties class Spam: def eggs(self): ... -- Steven -- https://mail.python.org/mailman/listinfo/python-list