homepage

In python is currently there a way to elegantly throw an error if a variable is already in the current scope?
For example:
def longfunc(self, filename):
 FILE = open(filename);
 header = FILE.readline();
 ... bunch of code ...
 childfiles = self.children;
 for child in childfiles:
 FILE = open(child);
 header = FILE.readline();
 ... do something with header ...
 for line in FILE:
 ... etc ...
In this case, I'm accidentally overriding the old values of FILE and header, resulting in a bug. But I'm not going to catch this. I've had a couple of real life bugs due to this that were a lot more subtle and lived for months without anyone noticing the output data was slightly wrong.
This situation could be prevented if there was a way to say something along the lines of "new FILE = open(child)" or "new header = FILE.readline()" and have python throw an error to let me know that it already exists. This would also make code clearer because it allows the intended scope of a variable to become more apparent. Since "new var = something" is a syntax error, adding this functionality wouldn't break old code, as long as python would allow for 'new' (or whatever the keyword would end up being) to also be a variable name (like "new new = 1" or "new = 1")

Interesting thought, the syntax seems unnecessary. Adding new syntax to the language is something that happens rarely and only with a _lot_ of consideration.
As a slightly more verbose alternative, currently you can do this:
 def fail_if_defined(*args, namespace):
 for name in args:
 if name in namespace:
 raise AlreadyBoundError(name)
And in your code you would put the following where you cared about it:
 
 fail_if_defined("FILE", "header", namespace=locals())
You could even drop the namespace parameter (since it's sort of boilerplate):
 def fail_if_defined(*args):
 namespace = inspect.currentframe().f_back.f_locals
 for name in args:
 if name in namespace:
 raise AlreadyBoundError(name)
However, if you are going to the trouble of sticking those in place (or of selectively using a new syntax), you are likely paying attention to the the situation already, rendering either solution unnecessary.
Ultimately, this is something better addressed instead by keeping your functions small, by being a little more cautious in naming, and particularly by careful unit testing.

I think this more the domain of pylint/pyflakes.

For starters, this would be most efficient implementation:
def unique(varname, value, scope):
 assert(not varname in scope);
 scope[varname] = value;
Usage:
unique('b', 1, locals());
print(b);
But you can't put that in a loop else it will false trigger. Ideally this wouldn't false trigger. This could be done by having python internally associate a line number with each explicit variable declaration.
Anyways, an external python function would be too slow for my use case. Likewise, since it would be something you could use a lot, it should be implemented in the underlying C code to give it minimal overhead.
Keeping functions small is very impractical at times. I shouldn't create 50 randomly named one use functions in my class as a safeguard against accidental overwriting when I have a legitimately complicated piece of code that can't be dissected without becoming unreadable. In many cases I might need 8 or 9 locals at a time in a single line in each loop section.
I don't see how this is the area of pylint/pyflakes at all. The idea is to make it so the human doesn't have to carefully inspect their code in order to decide if they made a mistake or not. Inspecting a long list of warnings is no better, and arguably I could pull up a bunch of python language design decisions and ask why they were made if pylint/pyflakes exists.
If such a change would have be implemented after much consideration and discussion, I don't see how closing my post helps accomplish that.

I suggest you mail python-ideas.