In yesterday's entry I advanced the idea that a significant part of why Python doesn't see much monkey patching (and Ruby does) is that you can't monkey patch a lot of fundamental Python classes and types because they're implemented in C. In sober hindsight, I think that I'm understating two intangibles (one of which I touched on in passing) in favour of a technical explanation.

First, I think that the effects of culture matter more than I initially thought. Culture plays a strong role in shaping how we write code in a language, both explicit in what people tell you to do and not do and implicit in things like what tutorials present and what approaches they take to solve problems. To invert the saying that you can write Fortran in any language, the reality is that people don't and culture is a good part of why.

Second is the issue of syntax. Ruby has a clear and direct syntax for adding your own methods to outside classes, while Python does not. In Python you have to go out of your way to modify a class after it's been created and the syntax is at least somewhat awkward and indirect. It's probably not longer (in lines) than the Ruby version, but it's certainly less direct and obvious. Since I'm a big believer that syntax matters I think that this can't help but have an effect in the two languages. I don't know if Ruby's syntax steers people towards monkey patching, but how it's both inobvious and a pain in Python has to steer people away from it.

Sidebar: the syntax in each language

In Ruby, monkey patching looks like this:

class SomeClass
  def newfunction
    [whatever]
  end
end

(I believe this is correct; I'm taking it from online examples, since I'm not a Ruby programmer.)

I think that this is the exact same Ruby syntax as you use when defining a full class yourself.

In Python, the equivalent is:

def newfunction(self, ...):
  [whatever]
SomeClass.newfunction = newfunction

This is shorter but less direct, involves more repetition, and doesn't clearly mark the new function as purely a class method (to be really equivalent to the Ruby version we should do 'del newfunction' to clean it out of our namespace). Full-scale lambdas would make this slightly better because then you wouldn't need to define the function separately and then glue it on to the class, but it would still look nothing like the way you define classes themselves.