Das deutsche Python-Forum

Code: Alles auswählen

class GameOfLive:

# Initialisierung
	def __init__(self):
		self.__m_yalt = 0
		self.__m_xalt = 0
		self.__m_x = 0
		self.__m_y = 0
		self.__m_anz = 0
		self.__m_fielddic = {}
		self.__m_lastgenerationdic={}
		self.__m_eingabe = 0

# setzen der ersten Zellen
	def platzieren(self, anz):		
        self.__m_fielddic[5,3]='C'
		self.__m_fielddic[4,4]='C'
		self.__m_fielddic[3,5]='C'
		self.__m_fielddic[4,6]='C'
		self.__m_fielddic[5,7]='C'
		self.__m_fielddic[6,6]='C'
		self.__m_fielddic[7,5]='C'
		self.__m_fielddic[6,4]='C'

# Nachbarn ermitteln
	def nachbar(self, x,y):
		self.__m_nachbar=[]
			for z in range (-1,2):
                for j in range (-1,2):
                    if x!=x+z or y!=y+j:
                         self.__m_nachbar.append([x+z,y+j])
                         return copy.copy(self.__m_nachbar)


	def ersetzen(self, nachbar):
		self.__m_nachbar=nachbar
		for item in self.__m_nachbar :		
			for z in range (0,2) :		
				if item[z]<0 :	
					item[z] = 9
				if item[z] >9 :	
					item [z]=0	
		return copy.copy(self.__m_nachbar)

# auswerten
	def auswerten(self, nachbar):
		self.__m_anz=0
		for item in nachbar:
            if self.__m_lastgenerationdic.has_key(tuple(item)):
                self.__anz+=1				
        return self.__m_anz

# wachsen
	def wachse(self,anz,x,y):
		if anz==3:	
            if self.__m_lastgenerationdic.has_key((x,y))==False:
                self.__m_fielddic[(x,y)]='C'								

# sterben
	def sterbe(self,anz,x,y):
		if (anz < 2) or (anz > 3):
            if self.__m_lastgenerationdic.has_key((x,y)):
                del self.__m_fielddic[(x,y)]		

# Attribut hole Feld nach Außen geben
	def holeFeld(self):
		return copy.copy(self.__m_fielddic)

# Letzte gerneration in einem anderen dictionary speichern
	def letztegerneration(self):
		self.__m_lastgeneration=copy.copy(self.__m_fielddic)



if __name__ == '__main__':

	gol=GameOfLive()
	field={}
	nachbar=[]
	eingabe=0
	zelle=0
	anz=0
	zahl=0
	
    gol.platzieren(zelle
    field=gol.holeFeld()
    print 'Startkombination'
    print
    for z in range (0,100):
        if z % 10 == 0 :
             print
        print  field.get((z%10, z/10),' '),
    print

    gol.letztegerneration()

    for i in range (0,100):
        nachbar=gol.nachbar(i%10,i/10)
        nachbar=gol.ersetzen(copy.copy(nachbar))
        anz=gol.auswerten(copy.copy(nachbar))
        gol.sterbe(anz,i%10,i/10)
        gol.wachse(anz,i%10,i/10)

    gol.holeFeld()
    print 'naechste gerneration'
    print
    for z in range (0,100):
        if z % 10 == 0 :
            print
        print field.get((z%10, z/10),' '),
    print

Code: Alles auswählen

nachbar = [1,2,3]
for item in nachbar:
    if item == 1:
        item = 100
print nachbar     # -> [1,2,3] nix verändert
for i in range(len(nachbar)):
    if nachbar[i] == 1:
        nachbar[i] = 2
print nachbar   # -> [2,2,3] jetzt passts

Code: Alles auswählen

	def platzieren(self, anz):
		i=0
# erste Zelle plazieren
		self.__m_x = randint(0,9)
		self.__m_y = randint(0,9)
		
		self.__m_fielddic [self.__x,self.__y] = 'C'
		self.__m_xalt=self.__x
		self.__m_yalt=self.__y
# weitere Zellen plazieren
		if anz-1>0:
			for i in anz
				self.__m_x = randint(-1,1)
				self.__m_y = randint(-1,1)

				if self.__m_x == 0 and self.__m_y == 0 :
					self.__m_x = 1
				if self.__m_yalt == self.__m_y :
					self.__m_y = self.__m_y* -1
				if self.__m_xalt == self.__m_x :
					self.__m_x = self.__m_x*-1

				if (((self.__m_xalt+self.__m_x<10) and (self.__m_yalt+self.__m_y<10)) and
					((self.__m_xalt+self.__m_x)>=0 and (self.__m_yalt+self.__m_y)>=0)) :
					
					if (((self.__m_xalt+self.__m_x),(self.__m_yalt+self.__m_y)) in self.__m_field) == 0 :
						if self.__m_fielddic.has_key(((self.__m_xalt+self.__m_x),(self.__m_yalt+self.__m_y)))==False :
							self.__m_fielddic[(self.__xalt+self.__x,self.__yalt+self.__y)] = 'C'
							i+=1
		else:
			return -4

Code: Alles auswählen

#!/usr/bin/env python

import time
from sets import Set as set

class GameOfLife:
    """Conway's *Game of Life*"""
    
    neighbour_positions = [(x, y) for x in xrange(-1, 2)
                                  for y in xrange(-1, 2)
                                  if not x == y == 0]
    
    def __init__(self, width, height, cells):
        self.width = width
        self.height = height
        self.cells = set(cells)
        self.clock = 0
    
    def __len__(self):
        return len(self.cells)
    
    def __str__(self):
        worldmap = [['.'] * self.width for dummy in xrange(self.height)]
        for x, y in self.cells:
            worldmap[y][x] = '#'
        return ('Clock: %d\n' % self.clock
                + '\n'.join([''.join(row) for row in worldmap]))
    
    def _is_within_world(self, field):
        x, y = field
        return 0 <= x < self.width and 0 <= y < self.height
    
    def _neighbour_fields(self, field):
        x, y = field
        for delta_x, delta_y in GameOfLife.neighbour_positions:
            neighbour_field = (x + delta_x, y + delta_y)
            if self._is_within_world(neighbour_field):
                yield neighbour_field
    
    def _fields_of_interest(self):
        fields = set(self.cells)
        for cell in self.cells:
            fields.update(self._neighbour_fields(cell))
        return fields
    
    def step(self):
        new_cells = set()
        
        for field in self._fields_of_interest():
            alive_neighbours = sum(map(int, [(neighbour_field in self.cells)
                                             for neighbour_field
                                             in self._neighbour_fields(field)]))
            if field in self.cells:
                # Cell `field` is alive.
                if 2 <= alive_neighbours <= 3:
                    new_cells.add(field)
            else:
                # Cell `field` is dead.
                if alive_neighbours == 3:
                    new_cells.add(field)
        
        self.cells = new_cells
        self.clock += 1
    
    def run(self, callback=None, steps=1000000):
        while len(self) and self.clock < steps:
            self.step()
            if callback is not None:
                callback(self)


if __name__ == '__main__':

    def display(obj):
        print '\033[H%s' % obj  # Cursor home and `obj` as string.
        time.sleep(0.5)

    game = GameOfLife(10, 10, ((5, 3), (4, 4), (3, 5), (4, 6),
                               (5, 7), (6, 6), (7, 5), (6, 4)))

    print '\033[2J'     # Clear screen.
    try:
        game.run(display)
    except KeyboardInterrupt:
        pass