What's bad about Python?

Because I'm learning it, almost done through the tutorial, and it looks great.

- Everything you write will be open source. No FASLs, DLLs or EXEs. There may be some very important instances where a business wouldn't want anybody to see the internal implementation of their modules and having strict control over levels of access are necessary. Python third-party library licensing is overly complex. Licenses like MIT allow you to create derived works as long as you maintain attrubution; GNU GPL, or other 'copyleft' licenses don't allow derived works without inheriting the same license (viral licensing). To inherit the benefits of an open source culture you also inherit the complexities of the licensing hell.
- Installation mentality, Python has inherited the idea that libraries should be installed, so it infact is designed to work inside unix package management, which basically contains a fair amount of baggage (library version issues) and reduced portability. Of course it must be possible to package libraries with your application, but its not conventional and can be hard to deploy as a desktop app due to cross platform issues, language version, etc. Open Source projects generally don't care about Windows, most open source developers use Linux because "Windows sucks".
- Python (like most other scripting languages) does not require variables to be declared, as (let (x 123) ...) in Lisp or int x = 123 in C/C++. This means that Python can't even detect a trivial typo - it will produce a program, which will continue working for hours until it reaches the typo - THEN go boom and you lost all unsaved data. Local and global scopes are unintuitive. Having variables leak after a for-loop can definitely be confusing. Worse, binding of loop indices can be very confusing; e.g. "for a in list: result.append(lambda: fcn(a))" probably won't do what you think it would.
- Probably the biggest practical problem with Python is that there's no well-defined API that doesn't change. This make life easier for Guido and tough on everybody else. That's the real cause of Python's "version hell".
- Python's garbage collection uses naive reference counting, which is slow and doesn't handle circular references, meaning you can't use arbitrary graphs as your data.
- Problems with arithmetic: no Numerical Tower (or even rational numbers or complex numbers), meaning 1/2 would produce 0, instead of 0.5, leading to various hard to notice errors.
- No switch (why not??)
- Expressions in default arguments are calculated when the function is defined, not when it’s called.
- Poor UTF support and unicode string handling is somewhat awkward
- No outstanding feature, that makes the language, like the brevity of APL or macros of Lisp.
- Python's lambda doesn't allow conditionals, a side effect of Python making a distinction between expressions and statements. Nor does Python have a useful form lambda. Python's implementation of lambda is limited to a single expression, virtually crippling it.
- No tail call optimization. "I don't like reading code that was written by someone trying to use tail recursion. It's the ultimate code obfuscation." --Guido Van Rossum
- Assignments are not expressions
- self everywhere can make you feel like OO was bolted on, even though it wasn't.
- Quite quirky e.g. __init__. Triple-quoted strings seem like a syntax-decision from a David Lynch movie, and double-underscores seem appropriate in C, but not in a language that provides list comprehensions. There has to be a better way to mark certain features as internal or special than just calling it __feature__.