Proposal for removing self

[Brent W. Hughes]

When doing object-oriented stuff, it bothers me to have to type "self" so
many times. I propose that Python allow the programmer to optionally type
".variable" instead of "self.varia ble" to mean the same thing. Of course,
the interpreter would have to be more careful about detecting floats that
begin with just a period as in ".5". What are your thoughts?

[Roger Binns]

Brent W. Hughes wrote:

When doing object-oriented stuff, it bothers me to have to type
"self" so many times. I propose that Python allow the programmer to
optionally type ".variable" instead of "self.varia ble" to mean the
same thing. Of course, the interpreter would have to be more careful
about detecting floats that begin with just a period as in ".5".
What are your thoughts?

When I started doing Python, it annoyed me. Now many years later
I definitely wouldn't change it. Guido has very good taste!

Roger

[Raymond Hettinger]

"Brent W. Hughes" <br**********@c omcast.net> wrote in message news:<T_7Xc.613 60$Fg5.2281@att bi_s53>...

When doing object-oriented stuff, it bothers me to have to type "self" so
many times. I propose that Python allow the programmer to optionally type
".variable" instead of "self.varia ble" to mean the same thing. Of course,
the interpreter would have to be more careful about detecting floats that
begin with just a period as in ".5". What are your thoughts?

There's a FAQ on the subject:

http://www.python.org/doc/faq/genera...ions-and-calls
Raymond Hettinger

[Raymond Hettinger]

"Brent W. Hughes" <br**********@c omcast.net> wrote in message news:<T_7Xc.613 60$Fg5.2281@att bi_s53>...

When doing object-oriented stuff, it bothers me to have to type "self" so
many times. I propose that Python allow the programmer to optionally type
".variable" instead of "self.varia ble" to mean the same thing. Of course,
the interpreter would have to be more careful about detecting floats that
begin with just a period as in ".5". What are your thoughts?

There's a FAQ on the subject:

http://www.python.org/doc/faq/genera...ions-and-calls
Raymond Hettinger

[Ravi Teja Bhupatiraju]

"Brent W. Hughes" <br**********@c omcast.net> wrote in message news:<T_7Xc.613 60$Fg5.2281@att bi_s53>...

When doing object-oriented stuff, it bothers me to have to type "self" so
many times. I propose that Python allow the programmer to optionally type
".variable" instead of "self.varia ble" to mean the same thing. Of course,
the interpreter would have to be more careful about detecting floats that
begin with just a period as in ".5". What are your thoughts?

I know that this has been proposed before and am familiar with the
alternatives commonly suggested. I understand that most Python
programmers are happy with things the way they are in this respect.
But after 3 years of Python, somehow, I still keep forgetting to type
the darn thing. Of course, I always catch the omission quickly but
that makes me wish there was a better alternative. Python has
generally been about less typing and self seems somewhat contrary to
that.

This following is not a carefully thought one but I would be
interested to know what your opinions are. The following is inspired
by win32all.

<from Python COM docs>
class HelloWorld:
_public_methods _ = ['Hello']
_public_attrs_ = ['softspace', 'noCalls']
_readonly_attrs _ = ['noCalls']

def __init__(self):
pass
</from Python COM docs>

How about having an optional attribute for a class that negates the
requirement for self?

One advantage with this is I can see all the member variables in one
place. Great while reading code.

<sample>
class FooBar:
__public__ = [Name, Age]
def setName(name):
Name = name
</sample>

While I am complaining, a few other peeves ...

Another thing is I dislike is having to use __ for *every* private
variable. For *me* __private__ at the top of the class definition code
would be more elegant. __readonly__ would be another nicety.

Introducing the above attributes into the language would not likely
break any existing Python code.

Just my 2c.

[Pierre-Frédéric Caillaud]

There was the "with" keyword :

with self:
.member = something
.member2 = .member3 + .member4

etc... it is a bit more implicit because of the "with"... anyway.

[Max M]

Brent W. Hughes wrote:

When doing object-oriented stuff, it bothers me to have to type "self" so
many times. I propose that Python allow the programmer to optionally type
".variable" instead of "self.varia ble" to mean the same thing. Of course,
the interpreter would have to be more careful about detecting floats that
begin with just a period as in ".5". What are your thoughts?

You don't have to use self. You could simply use underscore '_' instead.

class Person:

def setName(_, name):
_.name = name

def getName(_):
return _.name
But other Python programmers will hate you for it ;-)
If it is because you are using an attribute too many times inside a
method, a better solution is to map it to a local variable. It also has
the advantage of being faster.
class SoftwareProject Estimator:

pi = 3.14

def guestimatePrice (self, hours, hour_price, developer_group _size):
pi = self.pi
guess = hours * pi
guess *= pi * developer_group _size
return guess * hour_price
regards Max M

[Alex Martelli]

Andrea Griffini <ag****@tin.i t> wrote:

On 25 Aug 2004 22:23:46 -0700, ra****@cps.cmic h.edu (Ishwar Rattan)
wrote:

I concur for keeping self intact, it does provide clarity in code writing
and reading.
I remember Alex Martelli advocating in our italian newsgroup on
C++ that C++ programmers should use "this->..." everywhere :-)

I did that, and I did that before becoming mad with love for Python.

At the time my main job was helping hundreds of other programmers debug
their hairiest bugs (also helping them architect and design and test
things correctly, but debugging took far more time -- there's never time
to do it right so there's always time to do it over) and the lack of
this-> was a major cause of problems. confusions and bugs.
Seemed crazy to me at that time, but now after giving a try
to python I've to say that self-consciousness isn't bad.

If you write and debug truly complicated C++ templates you'll see why I
wanted explicit this-> prefixing most ardently...;-).
Alex

[Alex Martelli]

Ravi Teja Bhupatiraju <we*********@ya hoo.com> wrote:
...

<sample>
class FooBar:
__public__ = [Name, Age]
def setName(name):
Name = name
</sample>
Go ahead: learn about metaclasses and bytecode hacking and write your
custom metaclass to perform this. Except for the little detail that
you'll never get away with not quoting 'Name' and 'Age' in the
__public__ assignment, the rest is reasonably easy to perform. Publish
your metaclass and start campaigning for it.

As long as you're just yakking about it ain't gonna happen -- become a
metaclass and bytecode expert and you can implement this in Python, or
convince somebody who is such an expert, for which the implementation
should be the job of a couple days tops.

While I am complaining, a few other peeves ...

Another thing is I dislike is having to use __ for *every* private
variable. For *me* __private__ at the top of the class definition code
would be more elegant. __readonly__ would be another nicety.
That's an even easier job for a custom metaclass with very modest amount
of byecode hacking. I suggest you start with this one, really truly
VERY easy. In fact you could probably do it without any actual hacking
on the bytecode itself, just rewriting a few tables of strings in the
code objects of the functions that are the methods of the class.

One impossible task (THAT would require hacking the Python parser and
changing things very deeply) as I already mentioned would be the form
you want for the assignment to __public__ (or similarly to
__private__etc) . Those names are undefined (or worse defined globally)
and to teach Python (and human readers!) that for that one speclal case
of assignment to __public__ (or __private__), THAT one case only,
COMPLETELY different rules apply than ANYWHERE else in Python, well,
it's just as difficult as it is absurd.

I suggest you tackle the 'look ma no quotes!' task last, after
everything else is working, because that one detail is going to take far
longer than everything else put together, even if you're learning about
metaclasses and bytecodes from scratch.

Introducing the above attributes into the language would not likely
break any existing Python code.
If this peculiar behavior is limited to classes whose metaclass is your
custom RaviSpecial, "not likely" becomes "absolutely impossible", a
great enhancement. One more reason to implement this in a metaclass.
Just my 2c.

Well make it three cents and do an implementation, if you really care.
Otherwise, it's just words...
Alex

[Jacek Generowicz]

"Brent W. Hughes" <br**********@c omcast.net> writes:

When doing object-oriented stuff, it bothers me to have to type "self" so
many times.
When doing object-oriented stuff, it makes me extactic to write
"self." in front of instance attributes. The knowledge that other
programmers are always doing the same, makes me even more happy.

The fact that there are plenty of C++ and Java coding conventions
which require that all class members' names start with "m_", or that
all instance attributes be accessed, in methods, via "this->" or
"this." (depending) on the language in question, seems to support
Python's choice in this matter.
I propose that Python allow the programmer to optionally type
".variable" instead of "self.varia ble" to mean the same thing. Of course,
the interpreter would have to be more careful about detecting floats that
begin with just a period as in ".5". What are your thoughts?

I think you should get into the habit of reading FAQs, Archives,
Googling (you know, the usual stuff), before making such suggestions
publically.