> > Quite often the only answer is "just because". Some features are the > > way they are because that's Guido's pesonal preference. Others may > > disagree with him but it's his language and he gets to pick what he > > thinks is best - the benign dictator syndrome.
Hi Hugo, There are a few languages that have immutable values. For example, C and Java both define string literals to be immutable: trying to mutate them causes an error. (Well, C is supposed to raise a segmentation fault.) There are strong advantages to immutability: one of the main ones is that side-effect-less programming is less prone to certain kinds of bugs. For example, let's say we wanted a function to squish values together: ###### >>> def squish(A, B): ... """Creates a new list containing the elements of A and B""" ... result = [] ... result.extend(A) ... result.extend(B) ... return result ... >>> squish(range(5), range(7, 9)) [0, 1, 2, 3, 4, 7, 8] ###### An alternative way to write this might be: ###### >>> def smash(A, B): ... """Creates a new list containing the elements of A and B. ... Smashes the existing list A.""" ... A.extend(B) ... return A ... >>> smash(range(5), range(7, 9)) [0, 1, 2, 3, 4, 7, 8] ###### These both appear to have the same behavior but of course we know that something must be different between the two. *grin* If we have two lists, like: ###### >>> firstNames = ['hugo', 'keanu'] >>> lastNames = ['weaving', 'reeves'] ###### we can squish() them together: ###### >>> squish(firstNames, lastNames) ['hugo', 'keanu', 'weaving', 'reeves'] >>> >>> firstNames ['hugo', 'keanu'] >>> lastNames ['weaving', 'reeves'] ###### ... or we can smash() them: ###### >>> smash(firstNames, lastNames) ['hugo', 'keanu', 'weaving', 'reeves'] >>> >>> firstNames ['hugo', 'keanu', 'weaving', 'reeves'] >>> lastNames ['weaving', 'reeves'] ###### Oh! Notice that smash() messes with the list named by firstNames; when we finish calling it, we see a side effect: firstNames is smashed. The issue here is that we've let ourselves mutate our input values. Of course this is an exaggerated example, but it tries to make a point: having mutable values means we have to think about mutation. Mutation introduces a kind of "leakage" between functions. To make the situation more extreme: if we are working with someone else's code, and if we pass a mutable value to that external code, then if we see a bug later on in our own program, we may have to wonder if the external code mutated our values. That can be a big pain. (C programmers have to worry about this ALL THE TIME because they have pointers that let anyone smash up everything. *grin*) If we guarantee, though, that we are working with immutable values, we can toss them with abandon at anyone and know that they won't get munged. That's why immutability is an important concept in a programming language, and an especially useful one in a collaborative language like Python. Does this make sense? If you have more questions, please feel free to ask. _______________________________________________ Tutor maillist - Tutor@python.org http://mail.python.org/mailman/listinfo/tutor
