python default language cause problem on txt write

#Python default language cause problem on txt write code

You expect to get a new list referenced by a. Provided that python objects are mutable I think that this should be taken into account when designing the default arguments stuff. I know nothing about the Python interpreter inner workings (and I'm not an expert in compilers and interpreters either) so don't blame me if I propose anything unsensible or impossible. I suppose they could special-case using an empty list, but that kind of special casing would cause even more astonishment, not to mention be backwards incompatible. I personally like Python's current approach: default function arguments are evaluated when the function is defined and that object is always the default.

#Python default language cause problem on txt write code

Moreover, this is always the case when dealing with mutable variables you always run into cases where someone could intuitively expect one or the opposite behavior depending on what code they're writing. But I'd argue that if we 'fixed' this, then that would only create a different situation where they'd be bitten instead, and that one would be even less intuitive.

Your example is a good one of a case where Python newcomers will be surprised and bitten. Now, does my map use the value of the StringBuffer key when it was placed into the map, or does it store the key by reference? Either way, someone is astonished either the person who tried to get the object out of the Map using a value identical to the one they put it in with, or the person who can't seem to retrieve their object even though the key they're using is literally the same object that was used to put it into the map (this is actually why Python doesn't allow its mutable built-in data types to be used as dictionary keys). Here's a question: suppose in Java I have the following code: StringBuffer s = new StringBuffer('Hello World!') The real problem lies with mutable variables, and all languages have this problem to some extent. This would be more astonishing IMO than discovering that your foo function above was mutating the list. Then if default parameters were bound at function execution rather than function declaration, I would be astonished (in a very bad way) to discover that fruits had been changed. However, suppose later on in the code, I do something like def some_random_function(): When I see the declaration of eat, the least astonishing thing is to think that if the first parameter is not given, that it will be equal to the tuple ('apples', 'bananas', 'loganberries') Suppose you have the following code fruits = ('apples', 'bananas', 'loganberries') The actual behavior is more consistent: everything of that line gets evaluated when that line is executed, meaning at function definition. To me, it seems that the design decision was relative to where to put the scope of parameters: inside the function, or 'together' with it?ĭoing the binding inside the function would mean that x is effectively bound to the specified default when the function is called, not defined, something that would present a deep flaw: the def line would be 'hybrid' in the sense that part of the binding (of the function object) would happen at definition, and part (assignment of default parameters) at function invocation time.

Together with most of your comments and Utaal's in particular, I elaborated further: > def a(): However, I was not able to answer (to myself) the following question: what is the reason for binding the default argument at function definition, and not at function execution? I doubt the experienced behavior has a practical use (who really used static variables in C, without breeding bugs?)īaczek made an interesting example. I replied that the behavior had an underlying explanation, and it is indeed very puzzling and unexpected if you don't understand the internals. The result is instead very different, and very astonishing (for a novice): > foo()Ī manager of mine once had his first encounter with this feature, and called it 'a dramatic design flaw' of the language. Python novices would expect this function called with no parameter to always return a list with only one element. Anyone tinkering with Python long enough has been bitten (or torn to pieces) by the following issue: def foo(a=):