creating class objects inside methods

[Simon Forman]

On Sun, Oct 4, 2009 at 1:12 AM, horos11 <horos11 at gmail.com> wrote:
>
>> >>> a
>>
>> <__main__.Myclass instance at 0x95cd3ec>>>> b
>>
>> <__main__.Myclass instance at 0x95cd5ac>
>>
>> What's the problem?
>
> Like I said, the code was a sample of what I was trying to do, not the
> entire thing.. I just wanted to see if the metaphor was kosher.

Right, but it doesn't help if you post code that doesn't actually
display the unexpected behaviour you're asking about.

> It sounds to me from your answer that this is unexpected behavior, so
> I'll go ahead and post the whole thing. My guess is that it is a
> python bug..

/What/ is unexpected behaviour?  I ran the code you posted and worked
exactly like I expected.

Posting the whole thing is better than posting code that doesn't
display the issue, but this is too long.  I'd ask you to repost a
minimal version that actually displays the problem you're asking about
but I see from the rest of this thread that you've already figured it
out.

Related to that, two points.

Learn python AS python, don't get caught up in what it does
differently than other languages.  IMHO it's hands-down the most
useful. productive language out there for a tremendous number of
problem domains.  Treat yourself to it. ;]

And second, please don't /teach/ python until you've learned it...

Regards,
~simon

> Run it (a simple puzzle game solved by breadth first search), and the
> first time state() is called inside the method, it calls __init__.
> Second time, and therafter, it calls __call__. I've highlighted where
> the code fails by putting a pdb.set_trace().
>
> Anyways, I've got a workaround (simply pass in any new objects needed
> from the caller), but it is truly annoying that python is either
> misleading or broken in this way.
>
> Attached find code, does not work vs. 2.6..
>
>
> Ed
>
> ----
>
> from collections import deque
> import copy
> import pdb
>
> class state:
>
>    def default_board():
>
>        return [
>              [ 1, 'x', 'x', 0 ],
>              [ 2, 2,  3,  4 ],
>              [ 5, 6,  6,  7 ],
>              [ 5, 6,  6,  7 ],
>              [ 8, 9, 10, 10 ],
>              [ 0, 'x', 'x', 0 ]
>            ]
>
>    def default_types():
>
>        return {
>                1  : [ 0, 0 ],
>                2  : [ 0, 0, 0, 1 ],
>                3  : [ 0, 0 ],
>                4  : [ 0, 0 ],
>                5  : [ 0, 0, 1, 0 ],
>                6  : [ 0, 0, 1, 0, 0, 1, 1, 1 ],
>                7  : [ 0, 0, 1, 0 ],
>                8  : [ 0, 0 ],
>                9  : [ 0, 0 ],
>                10 : [ 0, 0, 0, 1 ]
>            }
>
>    def default_moves():
>
>        return []
>
>    def print_move(self, moveno, move):
>        print str(moveno) + ": " + str(move) + "\n"
>
>
>    def __init__(self, _board=default_board(), _moves=default_moves(),
> _types=default_types()):
>
>        self.board = _board
>        self.moves = _moves
>        self.types = _types
>
>    def possible_moves(self):
>
>        moves_so_far = set()
>        moves_so_far.add('x')
>        moves_so_far.add(0)
>        ret = []
>        for y_idx in range(0, len(self.board)):
>            for x_idx in range(0, len(self.board[y_idx])):
>
>                piece = self.board[y_idx][x_idx]
>
>                if not piece in moves_so_far:
>
>                    moves = self.legal_moves(y_idx, x_idx)
>                    moves_so_far.add(piece)
>
>                    if moves:
>                        ret.extend(moves)
>
>        return ret
>
>    def is_answer(self):
>
>        if self.board[5][3] == 1:
>            return True
>        else:
>            return False
>
>    def legal_moves(self, ycoord, xcoord):
>
>        ret = []
>        for dir in [ [ 0, 1 ], [ 0, -1 ], [ 1, 0 ], [ -1, 0 ] ]:
>            ret.extend(self.addmove(dir[0], dir[1], ycoord, xcoord))
>
>        return ret
>
>    def empty(self, type, ycoord, xcoord, pieceno):
>
>        for itr in range(0, len(type), 2):
>
>            yy = type[itr]
>            xx = type[itr+1]
>
>            if not (len(self.board) > (yy+ycoord) >= 0)  or not (len
> (self.board[yy+ycoord]) > xx+xcoord >= 0):
>                return False
>
>            if not self.board[yy+ycoord][xx+xcoord] in [ 0, pieceno ]:
>                return False
>
>        return True
>
>    def addmove(self, ymult, xmult, ycoord, xcoord):
>
>        ret = []
>        pieceno = self.board[ycoord][xcoord]
>        type    = self.types[pieceno]
>
>        if xmult != 0:
>            for xx in range(xcoord + xmult, -1 if xmult < 0 else 4, -1
> if xmult < 0 else 1):
> #               if xx == 0:
> #                   continue
>                if self.empty(type, ycoord, xx, pieceno):
>                    ret.append(self.newmove(ycoord, xcoord, ycoord,
> xx ))
>                else:
>                    break
>
>        if ymult != 0:
>            for yy in range(ycoord + ymult, -1 if ymult < 0 else 6, -1
> if ymult < 0 else 1):
> #               if yy == 0:
> #                   continue
>                if self.empty(type, yy, xcoord, pieceno):
>                    ret.append(self.newmove(ycoord, xcoord, yy,
> xcoord))
>                else:
>                    break
>
>        return ret
>
>    def newmove(self, fromy, fromx, toy, tox):
>
>        move = {
>                'fromx' : fromx,
>                'fromy' : fromy,
>                'toy'   : toy,
>                'tox'   : tox,
>                'piece' : self.board[fromy][fromx]
>                }
>
>        return move
>
>    def printout_path(self):
>
> #       print self
>        pdb.set_trace()
>        answer = state()
>
>        moveno = 0
>        print "\n==========================\n"
>
>        for moveno in range(0, len(self.moves)):
>            move = self.moves[moveno]
>            self.print_move(moveno, move)
>            answer.apply_move(move)
>            answer.print_board()
>        print "\n==========================\n"
>
>    def print_board(self):
>
>        for xx in self.board:
>
>            print ": ".join([ "%2s" % str(ii) for ii in xx ])
>
>    def to_string(self):
>
>        return str(self.board)
>
>    def apply_move(self, move):
>
>        self.moves.append(move)
>        num = self.board[move['fromy']][move['fromx']]
>        type = self.types[num]
>
>        for idx in range(0,len(type),2):
>            yy_delta = type[idx]
>            xx_delta = type[idx+1]
>            self.board[move['fromy']+ yy_delta][move['fromx']+
> xx_delta] = 0
>
>        for idx in range(0,len(type),2):
>            yy_delta = type[idx]
>            xx_delta = type[idx+1]
>            self.board[move['toy']+ yy_delta][move['tox']+ xx_delta] =
> num
>
>    def next_states(self):
>
>        ret = []
>        for move in self.possible_moves():
>            newstate = copy.deepcopy(self)
>            newstate.apply_move(move)
>            ret.append(newstate)
>
> #        pdb.set_trace()
> #        for xx in ret:
> #            print xx.__dict__
> #            print "\n"
>
>        return ret
>
> seen_states = set()
>
> start = state()
> dq    = deque()
>
> dq.append(start)
>
>
> while len(dq):
>
>    curstate = dq.popleft()
>    print "HERE " + str(curstate) + " => " + curstate.to_string() +
> "\n"
>    curstate.printout_path()
>
>    if curstate.is_answer():
>        curstate.printout_path()
>
>    elif curstate.to_string() in seen_states:
>        print "DUP " + curstate.to_string()
>
>    else:
>        seen_states.add(curstate.to_string())
>        for state in curstate.next_states():
>            if not state.to_string() in seen_states:
>                dq.append(state)
>
>                print "Trying..\n"
>                state.print_board()
>                print "\n"
> --
> http://mail.python.org/mailman/listinfo/python-list
>