On 04/04/2013 01:01 PM, frank ernest wrote:
Sorry about the indentation guys my mail service atomatically removed it when I
pasted the text (I tried to fix it by hand but it was hard to tell if I was
sucessful.)
I was tring to create a list object (self) and change it using the list methods
and some additional ones I will define in my class.
I wanted to create some varibles which I pass to most if not all of my methods.
Two of my variables are to be passed to the class apon creation of the object
and then they in turn are to be passed to all or most of the methods I create
(a, b in this case.) If I make a, b nonlocal I get the message that they are
already nonlocal.
I will need for debuging purposes to print my object in random places in my
class.
If I did this:
self.a = aWhat would that create (I'm thinking local variable?)?
No. a is a local variable, since it was passed as an argument. self.a
is an attribute of the alist instance.
class alist(): def __init__(self, b, a): self.mylist = list()
self.mylist.append(b) self.a = a + b def appendit(self): #I need to get a in
hear without passing #it in; it must come from the init method.
self.mylist.append(self.a) #(I hope I've updated the code well, I can't test it
from this computer.)PS: This is not the real code that I'm Emailing: I thought
I'd be better off with some simpler code that produces the same errors.
Your mail service is just broken, at least for use here. This is a text
forum, and your mail has an empty text body. So each of our mail
readers has to try to reconstruct the text from html nonsense. You can
see the result above of what Thunderbird does.
The following is what I think you posted.
class alist():
def __init__(self, b, a):
self.mylist = list()
self.mylist.append(b)
self.a = a + b
def appendit(self):
#I need to get a in hear without passing
#it in; it must come from the init method.
self.mylist.append(self.a)
#(I hope I've updated the code well, I can't test it from this
computer.)
There are lots of terminology problems which will stop you from
understanding what's going on.
"I wanted to create some varibles which I pass to most if not all of my
methods"
"Variables" passed to methods are called arguments, or parameters, and
that's NOT what you're trying to do. You're trying to have the
__init__() method "remember" those values. When you write "self.a ="
you are creating an "instance attribute" which is visible to all methods
on that instance. Other methods can access that instance attribute by
referring to it as self.a Not by "global" not by "nonlocal". Those
are very different. A local variable is also different, as is a class
attribute. You need to study up on each of these terms, and see what
the differences are in terms of lifetime, visibility, duplication, etc.
More on that later.
Now, the appendit() method is nonsensical, but perhaps it was just a
sample. Each time it's called, it'll append the same value a to the list.
Perhaps you'd be more comfortable if you wrote a __str__() method. That
way, when you try to print an instance, it'll do what you say, rather
than some default. Typically, it should do something with each
attribute that was initialized by __init__(). (untested)
def __str__(self):
res = "mylist attribute is" + str(self.mylist) + "\n"
res += "a is " + str(a) + "\n"
return res
Now you can exercise your class, and print out the results as often as
you like: (untested)
obj1 = alist(3, 47) # creates an instance of alist
print(obj1) # prints it
obj2 = alist(12, 9) # creates a second instance of alist, with its own
self.mylist and self.a, different from those in obj1
print(obj2)
obj1.append() #will take the particular list in obj1, and append the
saved self.a value
print(obj1)
obj2.append()
obj2.append()
print(obj)
Now, a brief, informal summary of all the different kinds of
"variables." A global variable is defined at the outer scope of a
module, and should mostly be constants, for sound engineering reasons.
The global keyword, used only inside a function, declares that a
particular variable that looks like it ought to be local, in fact is
global. The keyword applies only to that particular function.
A local variable is defined and used within a function (or method), and
vanishes entirely when the function returns. The formal parameters of
the function are locals as well.
A class attribute belongs to the class, and there's only one of them,
regardless of how many instances that class has.
An instance attribute exists separately in each instance of a class. It
should (my preference) be initialized in the __init__() method so that
every instance has the same attributes, even if it's just
self.att = None
A nonlocal variable is probably beyond what you need to know at the
present, but it's one that's either global, or in some other function.
When you say xxxx.yyyy the meaning of that depends entirely on what
xxxx is defined as. If xxxx is a class, then yyyy is an attribute of
that class. If xxxx is an instance, then yyyy might be an instance
attribute (usually) or a class attribute (if no instance attribute by
that name). If xxxx is a module, then yyyy is a global in that other
module.
The name self is a convention, but a very useful one there's no
advantage in breaking. Most methods take self as their first argument,
and it refers to the object that method is called with. In the specific
case of __init__() method, that object is newly created. In nearly all
other cases, it's the object specified to the left of the method name,
like obj1.appendit()
There are a few other tricks that might matter, but this should get you
going. Play with all these concepts, and become attuned to it. Only
then should you try to do things like inherit from list.
--
DaveA
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
http://mail.python.org/mailman/listinfo/tutor
