List comprehensions are a great example. If you want to reverse the keys and values of a dictionary you can do
reversed_dict = dict((value, key) for (key, value) in original_dict.items())
Whereas in c++ this would have to be something like... map<string, string> reversed_dict;
for (map<string, string>::iterator it = original_dict.begin();
it != original_dict.end(); ++it) {
reversed_dict[it->second] = it->first;
}
C++ may have added a lot of new stuff but they did not make the simple cases simple, they just made the simple cases possible but still ugly.If you're a python expert, clearly your answer is "yes! this is a great feature!". But that's what the C++ experts say too, even as their language buries itself under a mountain of complexity. From the outside looking in, I'm seeing exactly the same thing happen to python.
Some fancy features make a language fun and productive. Too many such features make it a mess.
List comprehensions were initially syntax for loops over generators. The current version introduces another variable scope.
alist = [foo(x) for x in things if isok(x)]
is equivalent to alist = []
for x in things:
if isok(x):
alist.append(foo(x))
Similarly it's not hard to explain what an @login_required or a @memoize decorator does, although it is tricky to write a decorator yourself. Same goes for generators.I don't think syntactic sugar is a bad thing. I wish C++ had better syntax. If I could never type hash_map<blah, blah>::iterator ever again, I would be happy. But that isn't the sort of feature that C++ tends to add.
2. Why do you thing that list comprehensions are so difficuilt to learn? iterators, generators and list comprehensions are easy and clean concepts.
If you want a feature, you write a lib. Once the feature is widely deployed it becomes a recognized pattern, so why not to include this one into the language?
Look at lambda or bind in boost - they are scary, but people still use them, since it's a powerful concept, and it would be much better to include them into the language.
For example, in a framework like Django they are used for permissions in views. So you can quickly just make sure a user is logged in or is an admin to see a specific view, all with an un-obtrusive @login_required.
I don't find any of these features bad - they are easy to read and useful.
But it didn't, for the simple reason that it looked funny because I haven't been keeping up with Python. I'll say it one last time: this idea, that the language should cater to its experts by adding features wherever possible, is what has killed C++ as a hacker's language. Python is walking blindly down the same path.
The decorator syntax is easier to read. It's at the top of the function where the arguments list and docstring are. Yes, there are tradeoffs when introducing new syntax, but decorators are definitely worth it.
This is the same thing that happened to C++. If you keep adding features that are useful to someone in some specific context, what you get is a more powerful language for an expert user writing code, but one that is much less productive for the people who have to maintain it.
And, can I just ask: how many ways to iterate over stuff does python really need?