Really, anything that changes instance data outside the constructor should worry you. And actually, Python's habit of requiring you to initialize attributes in __init__ is kind of annoying; stuff like Perl's Moose is much cleaner.
Yes, but default arguments are simply not intended for that. Decorators are. You wouldn't use default arguments as method metadata in Ruby, would you? Going for the "most concise syntax" in all cases gets you Perl, and Python is most definitely not Perl.
def subscribe(self, route=r'subscribe-(?P<name>[^@])@.'):
with:
@route('subscribe-(?P<name>[^@])@.'')
def subscribe(self):
and we can stop arguing.
I'm sticking to my guns on the instance variables, it's cleaner.
(We have an internal library at work that does something like:
def __init__(self, ..., foo={}):
self.foo = foo
Guess what happens when you change some_instance.foo. Yup, all the other instances change too!)With regards to instance variables:
On a request, the main process forks and a new instance of the route object is instantiated. Trust me, instance variables won't leak between requests:
This is what happens when a request comes in, the parameters to process_message are described here: http://docs.python.org/library/smtpd.html
@pytoad_decorator()
def process_message(self, peer, mailfrom, rcpttos, message_data):
for RouteClass in self.routes:
route = RouteClass(peer_ip=peer[0])
route.route(message_data) def __init__(self, ..., foo={}):
self.foo = foo
In this case, 'foo={}' is evaluated once, and returns a pointer to a dict(). After that, foo is always pointing to the same dict, not to a newly created empty dict.Run this in a Python interpreter:
class PhoneBook(object):
def __init__(self, names={}):
self.names = names
phonebook1 = PhoneBook()
phonebook2 = PhoneBook()
phonebook1.names['Bob'] = '+1 555 5555'
print phonebook2.names['Bob']
The only thing that is really safe to put in the defaults are immutable values.
I was shooting for the most concise syntax I could get. Why Python and not Ruby? I wanted to use Python's standard smtpd library, and their great libraries for dealing with RFC2822 emails.
Oh, in regards to the instance variables. It uses a forking based paradigm to handle requests, so the instance variables are not maintained from request to request.