Sambo a écrit :
By accident I assigned int to a class member 'count' which was
initialized to (empty) string and had no error till I tried to use it as
string, obviously. Why was there no error on assignment( near the end ).
Python is dynamically typed - which means that it's not the name that
holds type info, but the object itself. names are just, well, names...
BTW, I failed to see where you assigned an int to the class attribute
'count'. I just saw a try to call a string - which should raise a TypeError.
Do yourself (and anyone having to work on or with your code) a favour:
use new-style classes (ie : inherit from 'object'). And FWIW, the
convention for class names is CamelCase - preferably without MS-like
hungarian annotation.
group_name = ""
count = "0" #last time checked and processed/retrieved
first = "0"
last = ""
retrieval_type = "" # allways , ask( if more than some limit),
none
date_checked = ""
time_checked = ""
new_count = ""
new_first = ""
new_last = ""
# local storage maintanance vars
pointer_file = ""
message_file = ""
#maintanance vars cur_mess_num = 0
cur_mess_id = ""
All these are *class* attributes (meaning they belong to the class
object itself, not to instances). I really doubt this is what you want.
If you hope to have all the above as instance attributes, you must
assign them to the instance (usually in the __init__() method, which
main purpose is to initialize the newly created instance.
def __init__( self ):
group_name = ""
this creates a local variable 'group_name', bound to an empty string.
Using the reference to the current instance (usually named 'self', and
always passed in as first param) is *not* optional.
count = "0" #last time checked and processed/retrieved
and this creates a local variable 'count', bound to string '0'.
Of course, both are lost as soon as the __init__() returns.
def get_count( self ):
print self.count, type( self.count )
return string.atoi( self.count, 10 )
the string module is mostly deprecated. Use str object methods instead -
or if you just want to create an int from it's representation as a
string, int(self.count).
class server_info:
def "(server_info:
"get_group_stat( self, grp ):
invalid syntax.
and a problem with indentation here.
Tthis create a new instance attribute "group_name" on the gr_info
object. This instance attribute will shadow the class attribute of the
same name.
Also, FWIW, if you always know the value for group_name when
instanciating a Cgroup_info object, you might as well pass it to the
initializer.
try:
ind = self.group_list.index( grp )
The common convention for indices in each and every language is 'i'. If
you really want a meaningful name, then group_index would be better.
Also, for this kind of lookups, dicts are really faster than lists.
except ValueError:
gr_info.count(0)
I didn't see any method "count()" in the declaration of class
CGroup_info. I saw an attribute named "count", but it was bound to a
string - which is not callable.
parenthesis here are useless (and FWIW, they would be just as useless in
C++).
print ind
if len( self.group_list[ind].split() ) == 4:
gr_info.count = self.group_list[ind].split()[1]
gr_info.first = self.group_list[ind].split()[2]
gr_info.last = self.group_list[ind].split()[3]
group_list[ind] is the same as grp, isn't it ? if so, using grp directly
might be much more efficient *and* much more readable.
Also, you're calling 4 times the same method. This is highly
inefficient. Try this instead:
parts = grp.split()
if len(parts) == 4:
gr_info.count, gr_info.first, gr_info.last = parts[1:]
else:
gr_info.count = gr_info.first = gr_info.last = "0"
This style of "chained assignment" can be a real gotcha in Python. In
this case, it is safe since "0" is immutable. But using a mutable object
instead would lead to probably unexpected results. Try this:
a = b = []
a.append(1)
print b
You have to understand that Python "variables" (the correct name is
"bindings") are just the association (in a given namespace) of a name
and a *reference* (kind of a smart pointer) to an object.
Here's a possible rewrite of your code. It's certainly not how it should
be done, but (apart from going into wild guesses) it's difficult to come
up with anything better without knowing the specs. Anyway, it should
help you grasp a more pythonic way to do things:
class GroupInfo(object):
def __init__(self, group_name, count="0", first="0", last=""):
self.group_name = group_name
self.count = count #last time checked and processed/retrieved
self.first = first
self.last = last
self.retrieval_type = "" # always , ask( if more than some
limit), none
self.date_checked = ""
self.time_checked = ""
self.new_count = ""
self.new_first = ""
self.new_last = ""
# local storage maintanance vars
self.pointer_file = ""
self.message_file = ""
#maintanance vars
self.cur_mess_num = 0
self.cur_mess_id = ""
# if you want to store count as string
# but retrieve it as an int. The setter will
# be used by the initializer, and will then create
# the implementation attribute _count
def _get_count(self):
return int(self._count)
def _set_count(self, value):
self._count = str(value)
count = property(_get_count, _set_count)
class ServerInfo(object):
def __init__(self, ???)
self._groups = {} # dict lookup is faster
# ...
def has_group(self, group_name):
return self._groups.has_key(group_name)
def get_group_stat(self, group_name):
if not self.has_group(group_name):
return GroupInfo(group_name, "0")
parts = group_name.split()
if len(parts) != 4:
parts = [None, "0", "0", "0"]
return GroupInfo(group_name, *(parts[1:4]))
As a last point, I'd second Fredrik : don't try to write C++ in Python.
Learn to write Python instead. The (freely available) "Dive into Python"
book should be a good place to get started.
HTH
