Ray wrote:
> 1. Where are the access specifiers? (public, protected, private)
There's no enforceable way of doing these. The convention is that names
that begin with a single underscore are private to the
class/module/function/etc. Hence why sys._getframe() is considered a
hack -- it's not officially part of the sys module.
> 2. How does Python know whether a class is new style or old style?
> E.g.:
>
> class A:
> pass
That's an old-style class. All new-style classes inherit from object
(or another new-style class). So write it like:
class A(object):
pass
If you're just learning Python now, there's really no reason to use
old-style classes. They're only there for backwards compatibility.
> 3. In Java we have static (class) method and instance members. But this
> difference seems to blur in Python. I mean, when you bind a member
> variable in Python, is it static, or instance? It seems that everything
> is static (in the Java sense) in Python. Am I correct?
No, there's a difference, but things can get a little tricky. We'll
start with the easy one:
py> class A(object):
... x = 0 # "static", class-level
... def __init__(self):
... self.y = 1 # "non-static", instance-level
...
The difference between a "static", class-level attribute and a
"non-static", instance-level attribute is whether it's set on the class
object (e.g. in the class definition), or on the instance object (e.g.
by writing self.XXX = YYY). Playing with this a bit:
py> a = A()
py> A.x # read the class-level "x"
0
py> a.x # read the *class*-level "x" (but search through the instance)
0
py> A.y # try to read a class-level "y"
Traceback (most recent call last):
File "<interactive input>", line 1, in ?
AttributeError: type object 'A' has no attribute 'y'
py> a.y # read the instance-level "y"
1
Note that you can read "static" attributes from both the class and the
instance, and you can only read "non-static" attributes from the
instance, just like Java (IIRC).
Where you're likely to get confused is that instance level attributes
can shadow the class level attributes. That is, if you set an instance
attribute with the same name as a class attribute, you can't find the
class attribute through that instance anymore:
py> a.x = 2 # set the *instance*-level "x"
py> A.x # read the *unchanged* class-level "x"
0
py> a.x # read the *changed* instance-level "x"
2
HTH,
STeVe
--
http://mail.python.org/mailman/listinfo/python-list
