Python requires you to initialize a variable before reading it, so:

  foo = object
  ofo.__call__()

will cause a (runtime) error. Thus, if you use your declared variables, errors will occur on mistypes (unless, of course, you have the typo declared, which would be a smell in itself (think of variable names being too close))

OK, what if it is a flag variable that is either undefined or an integer? That is, do you need to initialize all variables?

Also, how about this?

  foo = 10
  ...
  if ...
    ofo = 20
  ...
  formula = bah * ( ... foo ... )

Edit: Please tell me the second case isn't as catastrophic as it looks? That would give at least me no ends of problems -- I thought modern languages left that kind of sh-t in the 1990s? Better have a good culture for testing!

1) If you want to read the variable in some way, you need to initalize it. If you want to do weird things involving setting random attributes on an object and check if they exist.. well, you're on your own. Generally, I'd recommend for the flag variable to have a definite uninitialized value (say, None), as this is far easier to check.

2) The opinion of a lot of people on python is that the lack of such (impossible[1]) compiletime tests requires you to replace them with good unit-tests (which should be written anyway). So yes, it is as bad as it looks, but it is recommended to test such things :) Also, there are tools like pychecker and pyflakes, which do sanity-checks which would capture these errors (even though they might be an insane valid python program[1]).

[1] This is impossible, as it is possible to set variables in earlier stack-frames inside a nested call, or I might fiddle around in the locals of an earlier call to get data I want. Certainly, no one would do this (and whoever does such a thing should be stabbed multiple times if this hack persists longer than an hour (hey, I have built such a thing myself to debug a deadlock about resources, it printed the direct caller of the allocation- and deallocation-method, so I could quickly check for unmatched alloc-calls :) )), but it is possible, and thus, the compiler has to assume such things happen.

My second example would bite me quite often.

Do I get this right?

You have to do really hard line testing to avoid simple problems that could be avoided if just variables had to be declared at first use? :-(

But like old C compilers, there is "lint"?

I'm all for nostalgia for old C compilers (except a buggy one, that stole weeks of my life). But that is strange.

I thought Python was all about safety and no problems because of a well designed syntax and coding standards akin to bondage?

Ah well, thanks for information!