Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

How to avoid explicit 'self' in Python?

I have been learning Python by following some pygame tutorials.

Therein I found extensive use of the keyword self, and coming from a primarily Java background, I find that I keep forgetting to type self. For example, instead of self.rect.centerx I would type rect.centerx, because, to me, rect is already a member variable of the class.

The Java parallel I can think of for this situation is having to prefix all references to member variables with this.

Am I stuck prefixing all member variables with self, or is there a way to declare them that would allow me to avoid having to do so?

Even if what I am suggesting isn't pythonic, I'd still like to know if it is possible.

I have taken a look at these related SO questions, but they don't quite answer what I am after:

Answer*

**In Java terms: Python doesn't have member functions, all class functions are static, and are called with a reference to the actual class instance as first argument when invoked as member function.**

This means that when your code has a `class MyClass` and you build an instance `m = MyClass()`, calling `m.do_something()` will be executed as `MyClass.do_something(m)`.

Also note that this first argument can _technically_ be called anything you want, but the convention is to use `self`, and you should stick to that convention if you want others (including your future self) to be able to easily read your code.

The result is there's never any confusion over what's a member and what's not, even without the full class definition visible. This leads to useful properties, such as: you can't add members which accidentally shadow non-members and thereby break code.

One extreme example: you can write a class without any knowledge of what base classes it might have, and always know whether you are accessing a member or not:

 class A(some_function()):
 def f(self):
 self.member = 42
 self.method()

That's the *complete* code! (some_function returns the type used as a base.)

Another, where the methods of a class are dynamically composed:

 class B(object):
 pass

 print B()
 # <__main__.B object at 0xb7e4082c>

 def B_init(self):
 self.answer = 42
 def B_str(self):
 return "<The answer is %s.>" % self.answer
 # notice these functions require no knowledge of the actual class
 # how hard are they to read and realize that "members" are used?

 B.__init__ = B_init
 B.__str__ = B_str

 print B()
 # <The answer is 42.>

Remember, both of these examples are extreme and you won't see them every day, nor am I suggesting you should often write code like this, but they do clearly show aspects of self being explicitly required.

Draft saved

Draft discarded

Edit Summary*

Cancel

6

Thank you. This answer hits the spot cos it also explains the benefits of using self.

bguiz
– bguiz

2010年01月01日 07:41:14 +00:00
Commented Jan 1, 2010 at 7:41
4

@Roger Pate: Please stop editing my question to remove python from it. I think that it belongs there. (and thanks for the answer!)

bguiz
– bguiz

2010年11月01日 03:25:13 +00:00
Commented Nov 1, 2010 at 3:25
3

@bguiz: It's SO convention to not duplicate the tags in the title. However, when I edited 2 days ago, I did not see you reverted the title 7 months ago.

Roger Pate
– Roger Pate

2010年11月01日 03:35:08 +00:00
Commented Nov 1, 2010 at 3:35
11

That's actually a rather silly-sounding reason. Python could fail to accept shadowing, and require you to declare it specifically, i.e. 'bless' your shadowing field with some kind of __shadow__ myFieldName. That would prevent accidental shadowing as well, wouldn't it?

einpoklum
– einpoklum

2015年04月09日 19:17:56 +00:00
Commented Apr 9, 2015 at 19:17
3

@dwjohnston Ok, I am years late to the party, but I have just started learning Python (my background is C++), and I hate typing 'self'. However I do like explicitly distinguishing locals from instance data. Would a Syntax extension making '.' == 'self.' be feasible to allow code like:

user1759557
– user1759557

2018年06月20日 01:11:39 +00:00
Commented Jun 20, 2018 at 1:11

| Show 6 more comments

How to Edit

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

How to Format

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

How to Tag

A tag is a keyword or label that categorizes your question with other, similar questions. Choose one or more (up to 5) tags that will help answerers to find and interpret your question.

complete the sentence: my question is about...
use tags that describe things or concepts that are essential, not incidental to your question
favor using existing popular tags
read the descriptions that appear below the tag

If your question is primarily about a topic for which you can't find a tag:

combine multiple words into single-words with hyphens (e.g. python-3.x), up to a maximum of 35 characters
creating new tags is a privilege; if you can't yet create a tag you need, then post this question without it, then ask the community to create it for you

popular tags »

lang-py

CollectivesTM on Stack Overflow

How to avoid explicit 'self' in Python?

Answer*