Python is not a great programming language.

It's great for beginners. Then it turns into a mess.

What's good

A huge ecosystem of good third-party libraries.
Named arguments.
Multiple inheritance.

What should be good

It's easy to learn and read. However, it's only easy to learn and read at the start. Once you get past "Hello world" Python can get really ugly and counterintuitive.
The Pythonic philosophy that "There should be one -- and preferably only one -- obvious way to do it." As someone who loves working within rules and rigid frameworks, I love this philosophy! As someone who writes Python, I really wish Python actually stuck to this philosophy. See below.

What's "meh"

Forced indentation. Some love it because it enforces consistency and a degree of readability. Some hate it because they think it enforces the wrong consistency. To each their own.
Dynamic typing. There are lots of dynamically-typed languages and lots of statically-typed languages. Which kind of typing is better isn't a Python debate, it's a general programming debate.

What's bad

400 ways (more or less) to interpolate strings. This prints "Hello Robin!" 3 times:
```
user = {'name': "Robin"}
print(f"Hello {user['name']}!")
print("Hello {name}!".format(**user))
print("Hello %(name)s!" % user)
```
If there was a unique and obvious use-case for each of these then that would be one thing, but there's not.
69 top-level functions that you have to just memorize. GvR's explanation sounds nice, but in reality it makes things confusing.
map doesn't return a list, even though the whole point of a mapping function is to create one list from another. Instead it returns a map object, which is pretty much useless since it's missing append, reverse, etc. So, you always have to wrap it in list(), or use a list comprehension, which, speaking of...
List comprehensions are held up as an excellent recent-ish addition to Python. People say they're readable. That's true for simple examples (e.g. [x**2 for x in range(10)]) but horribly untrue for slightly more complex examples (e.g. [[row[i] for row in matrix] for i in range(4)]). I chalk this up to...
Weird ordering in ternary/one-line expressions. Most languages follow a consistent order where first you declare conditions, then you do stuff based the on those conditions:
```
if user.isSignedIn then user.greet else error
```
```
for user in signedInUsers do user.greet
```
Python does this in the opposite order:
```
user.greet if user.isSignedIn else error
```
```
[user.greet for user in signedInUsers]
```
This is fine for simple examples. It's bad for more complex logic because you have to first find the middle of the expression before you can really understand what you're reading.
Syntax for tuples. If you write a single-item tuple (tuple,) but forget the trailing comma, it's no longer a tuple but an expression. This is a really easy mistake to make. Considering the only difference between tuples and lists is mutability, it would make much more sense to use the same syntax [syntax] as lists, which does not require a trailing comma, and add a freeze or immutable method. Speaking of...
There's no way to make dicts or complex objects immutable.
Regular expressions require a lot of boilerplate:
```
re.compile(r"regex", re.I | re.M)
```
Compared to JavaScript or Ruby:
```
/regex/ig
```
The goofy string literal syntaxes: f'', u'', b'', r''.
The many "magic" __double-underscore__ attributes that you just have to memorize.
You can't reliably catch all errors and their messages in one statement. Instead you have to use something like sys.exc_info()[0]. You shouldn't have a catch-all in production of course, but in development it's very useful, so this unintuitive extra step is annoying.
Dev environments. Setting up an environment is a problem in any langauge, but other languages have solved the problem better than Python. For example, while npm has its warts, it is widely accepted that a fresh environment should be set up with npm i && npm run [script]. Meanwhile each Python project seems to require a unique mish-mash of pip and pipenv and venv and other shell commands.

What's bad about the culture

Most programmers will acknowledge criticisms of their favorite language. Instead, Pythonists will say, "You just don't understand Python."

Most programmers will say a piece of code is bad if it's inefficient or hard to read. Pythonists will say a piece of code is bad if "it isn't Pythonic enough." This is about as helpful as someone saying your taste in music is bad because "it isn't cultured enough."

Pythonists have a bit of a superiority complex.

I would like to share something that I consider a principal issue with python. I think of functions as one of the most important abstraction in programming, or even the most important abstraction. It is fucked up in python. Yes, the named arguments is a good feature. But let's talk about how can you reason about a function input and output. The input can be hidden behind the infamous args and kwargs utility. They are passed in an invisible way and you just don't know whether they exist and where they are used. You have to trace all calls and to inspect all internal usage in order to find out. Someone can say that it is a bad practice, but I consider it a wrong utility that encourages wrong usage. Now let's reason about the return result. Since it's a dynamic type we don't know, it can be string, json, none, anything. And even more! The return result type can vary depending on one of those invisible input arguments that are so conveniently passed. So, in essence we can end up with a function that has no strict notion about input and output, it breaks up the most important abstractions in programming. This is my experience from a real world usage, and the code is written by people who are fond of the "pythonic" way of doing things. It's just horrible.
And yes, the forced indentation is bad, it makes the code less readable to me.

RobertAKARobin/python.md