classes and __init__ question

[Alex Hall]

Hi all,
I am a bit confused about classes. What do you pass a class, since all
the actual information is passed to __init__? For example, say you
have a dog class. The dog object has a name, a size, and a color. I
believe you would say this:

class dog():
def __init__(self, name, size, color):
self.name=name
self.size=size
self.color=color
#end def
#end class

What, then, gets passed to the class constructor?
class dog(whatGoesHere?):
Sometimes I see things passed to this. For example, if you create a
class for a wxPython frame, you will say:
class myapp(wx.App):
In this case you pass something. However, I have a class that I use in
one of my programs to create "contact" objects, which looks like this:
class contact():
def __init__(self, name, email, status, service):
self.name=name
self.email=email
self.status=status
self.service=service
#end def
#end class

Here, I do not pass anything to the class, only to __init__. What is going on?

On a related note, is it horrible for resource usage to create a large
array, up to 500 or so, where each member is a small object? I am
thinking of, for example, a game board array where each member of the
array is a "square" object. A square might have a status, a color, and
other flags associated with it, so you could then say something like
board[j].hasGamePiece=True. Lookups and adjustments like this will
be going on a lot. Am I better off using an array of numbers where
each number means something different?

Thanks in advance for any info.

 

[Patrick Maupin]

Hi all,
I am a bit confused about classes. What do you pass a class, since all
the actual information is passed to __init__? For example, say you
have a dog class. The dog object has a name, a size, and a color. I
believe you would say this:

class dog():
 def __init__(self, name, size, color):
  self.name=name
  self.size=size
  self.color=color
 #end def
#end class

What, then, gets passed to the class constructor?
class dog(whatGoesHere?):
Sometimes I see things passed to this. For example, if you create a
class for a wxPython frame, you will say:
class myapp(wx.App):
In this case you pass something. However, I have a class that I use in
one of my programs to create "contact" objects, which looks like this:
class contact():
 def __init__(self, name, email, status, service):
  self.name=name
  self.email=email
  self.status=status
  self.service=service
 #end def
#end class

Here, I do not pass anything to the class, only to __init__. What is going on?

On a related note, is it horrible for resource usage to create a large
array, up to 500 or so, where each member is a small object? I am
thinking of, for example, a game board array where each member of the
array is a "square" object. A square might have a status, a color, and
other flags associated with it, so you could then say something like
board[j].hasGamePiece=True. Lookups and adjustments like this will
be going on a lot. Am I better off using an array of numbers where
each number means something different?

Thanks in advance for any info.

What you are calling "passing to a class" is the superclass (or list
of superclasses) if you are creating a subclass.

Under Python 2.x, you might want to subclass object (if you need/want
a newstyle class), so it is fairly common to see:

class foo(object):
whatever

Regards,
Pat

 

[Alex Hall]

Hi all,
I am a bit confused about classes. What do you pass a class, since all
the actual information is passed to __init__? For example, say you
have a dog class. The dog object has a name, a size, and a color. I
believe you would say this:

class dog():
def __init__(self, name, size, color):
self.name=name
self.size=size
self.color=color
#end def
#end class

What, then, gets passed to the class constructor?
class dog(whatGoesHere?):
Sometimes I see things passed to this. For example, if you create a
class for a wxPython frame, you will say:
class myapp(wx.App):
In this case you pass something. However, I have a class that I use in
one of my programs to create "contact" objects, which looks like this:
class contact():
def __init__(self, name, email, status, service):
self.name=name
self.email=email
self.status=status
self.service=service
#end def
#end class

Here, I do not pass anything to the class, only to __init__. What is going
on?

On a related note, is it horrible for resource usage to create a large
array, up to 500 or so, where each member is a small object? I am
thinking of, for example, a game board array where each member of the
array is a "square" object. A square might have a status, a color, and
other flags associated with it, so you could then say something like
board[j].hasGamePiece=True. Lookups and adjustments like this will
be going on a lot. Am I better off using an array of numbers where
each number means something different?

Thanks in advance for any info.

What you are calling "passing to a class" is the superclass (or list
of superclasses) if you are creating a subclass.

So what is a subclass compared to a class? Are you saying that what is
passed to the class, so what is in the parentheses of the class, is
really the superclass? If so, what is the advantage of doing this; why
not just create a class that is not a sub? I thinking I am missing
something elementary here.

Under Python 2.x, you might want to subclass object (if you need/want
a newstyle class), so it is fairly common to see:

class foo(object):
whatever

In Java, a class is an object. Is Python the same thing? Would you say
that my dog class, for example, creates a new dog object when an
instance is instantiated?
Thanks.

 

[Patrick Maupin]

So what is a subclass compared to a class? Are you saying that what is
passed to the class, so what is in the parentheses of the class, is
really the superclass? If so, what is the advantage of doing this; why
not just create a class that is not a sub? I thinking I am missing
something elementary here.

A subclass can inherit methods and attributes from a base class. This
is not necessary, but is sometimes useful.

In Java, a class is an object. Is Python the same thing?

Yes, a class is an object. A class's class is its "metaclass".

An instance of a class is also an object.

Would you say
that my dog class, for example, creates a new dog object when an
instance is instantiated?

Yes. But the actual act of coding something like:

class foo(object):
pass

Creates a class object, which is a subclass of the 'object' object,
and is an instance of the 'type' object. Since Python is so dynamic,
you can easily determine this at the command prompt:
.... pass
....

Regards,
Pat