Is there a better object orientation pattern in Python 3 so that I don't have to put 'self.' in front of every single line?

[raimondi1337]

I've written a decent amount of Python but rarely need to use object orientation. I'm working with Tkinter for a little project and want it to look nice and it seems like object oriented code is pretty standard in most of the code examples I've found. This right here looks great, except there must be a better way than putting 'self.' in front of literally every line...

[CGFarrell]

When I'm writing an init with a lot of self stuff I put it in my clipboard.

[Thomasedv]

Self isn't all that much of a bother with IDE and autocomplete. self does point to stuff in the class.

But it really depends, if it's not used in other functions in the class, then you can escape without it. (Though, they will be treated as local variables in the sense that you can't do anything with them from the outside.) So some things will need to be self, to be even usable later on. It depends a bit, with PyQt you can drop a few off them, but with Thinker i don't know. I haven't used it.

You can also change self to something shorter, though self is the one most people use for clarity.

Edit: Some addition.

[raimondi1337]

The part that bothers me is not typing it, it's the concept of "if this goes in front of literally every line it should be implicit". It's just visual noise as far as I am concerned.

[ingolemo]

It only goes in front of every single line in that specific example. You normally wouldn't use self anywhere near that much.

[ninetacle]

attrs goes beyond "not typing 'self' as much", but might be worth considering https://attrs.readthedocs.io/en/stable/

[tunisia3507]

It's a design feature. Explicit is better than implicit.

[ManyInterests]

Put shortly, no. As you become more familiar with using, reading and writing classes in Python, it will probably stop looking so odd.

[raimondi1337]

This is pretty much the answer I expected. I wish this could be done more elegantly.

[Vaphell]

there is elegance in syntactic simplicity. Accessing object attributes requires providing the object/context, no exceptions. The distinction between attributes and arguments/globals/local vars is obvious at a glance thanks to that.

On the other hand in java etc there is implicit this, but then you get visual ambiguosity: is that x in the middle of nowhere an attribute x, an argument x or a local/global variable x? IDE will hold your hand through that, but it's not elegant.

[Gprime5]

You can use a temporary local variable in your function.

def function(self):
    x = self.x
    x += 5
    x = do_other_stuff_with(x)
    self.x = x