> Why is it an unwanted thing?

Let's take the following code snippet as an example:

    class Foo:
      def bar(val):
        foo = val

I claim that most of the time this is a mistake, and the author would have preferred `def bar(self, val): self.foo = val`. In current python, this will raise an exception when called. In your proposed python, this will silently do nothing, possibly leaving the instance in an invalid state. This is a footgun. I admit the example is contrived, but forgetting `self` is a thing I've seen happen, and having it fail loudly is preferable to having it do something likely unintended. Again, if someone wants to do the unusual thing, `@staticmethod` is still around.

> With partial() specifically, of course you can avoid that in this manner. But why would you, if it works with regular functions?

Simply: because I'd prefer it if functions look like functions. Understanding that `def x` is a callable is easier than trying to discern if `x = foo(other_thing)` results in x being callable or not, where it does for some values of `foo`, but not for others. Which isn't to say that python shouldn't make this change, I think I mostly agree with your complaint, I just probably wouldn't take advantage of it.

> My complaint is of course more complicated than the syntax alone.

To be frank, I don't see any connection between your syntactical suggestions and your semantic ones. They seem to be entirely orthogonal.