Python Is Not A Great Programming Language

python.md

Python is not a great programming language.

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

• What's good
• What should be good
• What's "meh"
• What's bad
• What's bad about the culture

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.

What's Good

I agree to these points and could add many more.

What should be good

That's a bit blurry, so I can not criticize or agree.

What's "meh"*

Forced Indentation
Okay, that can create problems, like indentation getting lost when copying from the Internet. That happened once to me since I use Python. In practice, it is no problem.

Dynamic typing.
What are you missing in today's Python type system?

To the above I would add:

Verbose syntax for dataclasses

One needs to write "class" four times before using the first data. Python needs a data keyword to create data (structs in C, I guess), which would be close to JS expressiveness.

No let block defining space for temp variables

Python does not have that:

let foo, bar:
    baz = 3
    foo = baz * 2
    bar = baz * 5
# foo is 6, bar is 15, baz is not known.

in JS, I can write:

let foo, bar; {
    let baz = 3;
    foo = baz * 2;
    bar = baz * 5;
}
// foo is 6, bar is 15, baz is not known.

No section blocks

"A description of what follows. You can fold this in your editor":
    # here code

What's bad

400 ways (more or less) to interpolate strings
I also dislike using "%" for string interpolation. I use f-strings, if possible. The .format(...) syntax is needed when the format string is inside a variable. That makes one obvious way to do it for every use case and one way, probably kept for backwards compatibility. Not too bad.

69 top-level functions
Why do you need to memorize them? Your IDE has autocomplete, you can print out a cheat sheet, or keep that site open as a pinned tab. Also, your brain has memorized thousands of words in your mother tongue and other languages. When you use Python daily, you will soon have memorized these little lib function names too. I never have to search for them, working is very productive. list, set, dict, print, try to memorize their equivalents and their usage in Java or other languages.

map doesn't return a list
And that makes sense. If you want to map thirty functions over the list you don't want to create a new list in memory each time. And is wrapping in list(...) really so ugly? It is explicit and short. I not just got used to it, I started to like it. Same with generators, iterators, context managers, ...

[[row[i] for row in matrix] for i in range(4)])
Whatever you are trying to do here, you can and probably should write

for i in range(4):
    for row in matrix:
        mylist.append(row[i]) 

The next point is the same, these shortcuts should not be used when the task is complex. Use a normal if / for block statement.

Syntax for tuples
It is a short syntax, but I find it intuitive. I have never run into that error in practice, as far as I remember. How often did you use a one element tuple? And how often have you run into that specific error and were not able to quickly find its cause? Some things just have a short syntax, and it does not hurt. Would you complain about string literals being wrapped in just " and "? I guess no, because you are used to it. (for the records, you don't even need the brackets, you can write mytuple = 1, and I like this!)

Frozen dict, frozen objects
For a frozen dict, create a subclass and overwrite __setitem__. There are libs for other frozen objects. But for what do you need frozen things? I never did.

Regular expressions have a verbose syntax.
Accepted, JavaScript is better in object access syntax and simple regexes. But try to write a complex regex in JS and you will experience pain, while in Python you have re.VERBOSE. Ok, I once figured out a smart workaround for Javascript.

Goofy string syntax
Same as with the tuple syntax, it is often used, and I like that it is short. What would be a non-goofy syntax in your opinion?

Magic underscore syntax
I think it is very expressive. I also just have __init__ __name__, __main__, __slots__ and __pycache__ in my memory. For everything else a Google search or print(dir(<thing>)) or print(help(<thing>)). 90% of these I have never used. You do not need to memorize them.

No Exception catch-all

I do not understand.

try:
    ...
except:
    ...  # Voila, nearly all errors catched - including those you never intended to.

More info.

Many dev environments

Yeah, I did not like that too. But today everybody seems to use venv or no virtual environment, it has gotten better.

This thread is whole LOL. LMAO

My sis (3rd year in graduation) having a code test for an interview and asked for help...
Her classmates selected python to do the code and so is she.

As there is lot of hype being in, So... I too thought of giving a try and learn.
Also, have been planning to learn never got a reason.

As soon as I begin, I baffled with indentation as syntax and then for scope.
Just imagining consequences of overlooking the indentation while copying code or something
that gonna create a hell of mess and security constrains.

Just by going through the concepts. I didn't understand reason the hype is like it's best for everypurpose.
Thought that am I only the one? luckily this thread save me.

Then with intro of new forms of unnecessary things, methods and dependencies.
I amazed, how it survived with out buzz of it's ridiculousness.

I like to create things of my own, rather than falling much on dependencies.
For me programming is that being independent.

For prototyping, yes. It is quick and easy for small blocks of code to Test.
Till there it's fine, if goes further more will be a pain in the ass.

My view is like, it will only be ok for DataScience and where in need of minimal code like testing algorithms.
Where the people don't need to have much need to understand primitives and their reasons.
Except only to just get work done.

Apart from that don't see much of a use. Except to create more confusion and a push towards wilderness for learning python.

A little LOL : https://www.youtube.com/shorts/lqjeojLHQyk
Have Fun Programming... :-)

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.

@svilst

How can you reason about a function input and output.

By adding type signatures.

The input can be hidden behind the infamous args and kwargs utility.

Annotate them too.

Now let's reason about the return result.

Use type signatures for that too. To denote different return types, separate them with |.

And yes, the forced indentation is bad, it makes the code less readable to me.

Okay, in that case, it is probably best to stay away. Pythonistas dont like bracket revoluzzers :-D

This misses the point - Python as a language is terrible, and using third party tools and other hacks does not change that.

Type signatures are not enforced, you have to run a third party tool. I've never seen them used in the wild and are constantly forced to dive into some library to see what a function is actually returning.

Likewise getting rid of the forced indention is just another third party hack to repair a feature of a bad language.

Type signatures are not enforced, you have to run a third party tool.

It is not difficult to get that working in VS Code. It will suggest you to install the related Microsoft hosted package, which includes a type checker, and you are ready to go.

Likewise getting rid of the forced indention is just another third party hack to repair a feature of a bad language.

I can not change the way how you look at Python. But in practical application, indentation is a rather negligible detail which does not decide if the code gets written. That would be the availability of documentation and packages, the support of the user base, and the elegance of the language syntax.

"The elegance of the language syntax"? You're kidding, right? It's horrible. The handling of control structures and numbers is as far from elegant as you can get; they're a kludged together mess. And the total lack of enforced structure to definitions and "classes" leads to the worst sort of jigsaw code where the reader is scrambling around trying to work out which bits belong to which entity. And, yes, the whitespace is a dumb idea which is a problem in real life. An editor *might* make it straight-forward to cope with, but that doesn't mean that the language designer wasn't at fault when he took that whimsical decision and then refused to budge on it. Luckily, there's lots of good modules written in C or C++ which you can call from Python so it's not a complete waste of space. Unless you know C or C++, of course, in which case it's a bit redundant. Regards,

…

-- *Thomas*

The handling of control structures ...

I would love to see some examples.

and numbers is as far from elegant as you can get; they're a kludged together mess.

Ditto

And the total lack of enforced structure to definitions and "classes" leads to the worst sort of jigsaw code (...)

Ditto

And, yes, the whitespace is a dumb idea which is a problem in real life. (...)

Ditto