← Back to context

Comment by mattclarkdotnet

5 days ago

It's still ridiculous. A hypothetical Python4 would treat function declarations as declarations not executable statements, with no impact on real world code except to remove all the boilerplate checks.

There is no such thing as a "function declaration" in Python. The keyword is "def", which is the first three letters of the word "define" (and not a prefix of "declare"), for a reason.

The entire point of it being an executable statement is to let you change things on the fly. This is key to how the REPL works. If I have `def foo(): ...` twice, the second one overwrites the first. There's no need to do any checks ahead of time, and it works the same way in the REPL as in a source file, without any special logic, for the exact same reason that `foo = 1` works when done twice. It's actually very elegant.

People who don't like these decisions have plenty of other options for languages they can use. Only Python is Python. Python should not become not-Python in order to satisfy people who don't like Python and don't understand what Python is trying to be.

You think so but then you write a function with a default argument pointing to some variable that is a list and now suddenly the semantics of that are... what?

  • you could just treat argument initialization as an executable expression which is called every time you call a function. If you have a=[], then it's a new [] every time. If a=MYLIST then it's a reference to the same MYLIST. Simple. And most sane languages do it this way, I really don't know why python has (and maintain) this quirk.

    • What are the semantics of the following:

          b = ComplexObject (...)
          # do things with b
      
          def foo (self, arg=b):
              # use b
      
          return foo
      

      Should it create a copy of b every time the function is invoked? If you want that right now, you can just call b.copy (), when you always create that copy, then you can not implement the current choice.

      Should the semantic of this be any different? :

          def foo (self, arg=ComplexObject (...)):
      

      Now imagine a:

          ComplexObject = list

      3 replies →

You are describing a completely different language, that differs in very major ways from Python. You can of course create that, but please don't call it Python 4 !