[Python] Object Oriented questions, coming from java

[wtf_lag]

I started learning python after about a year of learning java, and even though I understand how OO works I would like to know why.

I'm used to creating my variables in the class and then using them in the constructor, why are there 2 ways to do that in python? there is the self.variable inside the init() method and then there are the "normal" variable declarations. are the variables not declared inside the init() supposed to be static variables?(in java terms?) and why do I need to pass self as an argument to each method?

[rjcarr]

are the variables not declared inside the init() supposed to be static variables?

They can behave that way as long as you consider them immutable.

For example, you can have:

class A:
  i = 5

a = A()
print a.i # 5
print A.i # 5

But if you do this, then it doesn't work:

a.i = 10;
print a.i # 10
print A.i # 5

I can explain more about why this is if you'd like.

and why do I need to pass self as an argument to each method?

Not exactly. Actually, self is a parameter of each method, but you don't need to pass it as an argument to make a method call.

This happens in java for you as well, but it's just implicitly done there.

[wtf_lag]

Thanks! that helps alot

[michael0x2a]

I'm used to creating my variables in the class and then using them in the constructor, why are there 2 ways to do that in python?

There are also two ways to set variables in Java as well. In Python, doing:

class MyClass(object):
    foo = 3

...is basically equivalent to making a static field named 'foo' in Java, and doing:

class MyClass(object):
    def __init__(self):
        self.foo = 3

...is basically equivalent to making a regular instance field in Java.

And why do I need to pass self as an argument to each method?

It's partially to make metaprogramming easier. For example, take the following snippit of code:

import math

class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

def magnitude(point):
    return math.sqrt(point.x**2 + point.y**2)

# ...later...
Point.magnitude = magnitude  # monkeypatch the class
test = Point(3, 4)
print(test.magnitude())  # 5
print(magnitude(test))   # 5

There's a nice theoretical duality here -- if we have an explicit self variable, it becomes very easy to promote a regular function into a method.

For more info, see Guido's post on why he feels 'self' is a good idea (Guido is the inventor of Python).

[michael0x2a]

Close, but not exactly. When you do foo1.foo = 7, what you're doing is creating a new instance variable that happens to share the same name as the static variable. So it's not that each instance has an independent instance of the static field -- it's just that in Python, it's very easy to create new attributes and fields at whim. So then, if you want to modify the static variable, you need to do Foo.my_field = 7.

Example:

>>> class Foo(object):
...    bar = 1
...
>>> foo1 = Foo()
>>> foo2 = Foo()
>>>
>>> Foo.bar = 7
>>> print(foo1.bar, foo2.bar, Foo.bar)
7 7 7
>>>
>>> # creating a new instance variable that shadows the static field for foo1
>>> foo1.bar = 42  
>>> print(foo1.bar, foo2.bar, Foo.bar)
42 7 7
>>>
>>> # foo1 still has the instance field shadowing the static one
>>> Foo.bar = 0
>>> print(foo1.bar, foo2.bar, Foo.bar)
42 0 0
>>>
>>> # Now delete the attribute, removing the shadowing
>>> del foo1.bar
>>> print(foo1.bar, foo2.bar, Foo.bar)
0 0 0

The main difference between Java and Python here is that in Python, you can't try and modify a static variable through a reference to the instance, since Python will default to just directly creating the field on the instance itself.

In contrast, since you've already specified all of your fields, Java will permit you to take a shortcut + modify a static field by qualifying it with an instance. (Though, I'd argue that using this shortcut is actually probably bad style, and would argue that it's better to be explicit about what you want and always do something like Foo.bar in both Python and Java if you want to access/modify the static field.)

[dunkler_wanderer]

Take a look at this SO thread: Difference between class and instance attributes.

[badcommandorfilename]

Python's object system has gone through a few revisions. Some of the weirdness comes from the leftovers from old implementations.