Programmers Day program: A glider!

En honor al día del programador , hice este pequeño programa...
un Glider del juego de la vida, a 10 iteraciones sobre una rejilla de 6x6 con frontera abierta...

Felicidades programadores!

glider = [[0, 0, 1, 0, 0, 0],
          [1, 0, 1, 0, 0, 0],
          [0, 1, 1, 0, 0, 0],
          [0, 0, 0, 0, 0, 0],
          [0, 0, 0, 0, 0, 0],
          [0, 0, 0, 0, 0, 0]
         ]

def printg(grid):
    """                                                                                                                             
    Imprime un arreglo bidimensional.                                                                                               
                                                                                                                                    
    Cambia los 0's por puntos '.' para mayor claridad.                                                                              
    """
    for i in range(len(grid)):
        row = ""
        for j in range(len(grid[i])):
            row += str(grid[i][j]) if grid[i][j] == 1 else '.'
        print row

def vecindad ((y,x), grid):
    """                                                                                                                             
    Vecindad de VonNeumann de una celda dada en la rejilla.                                                                         
                                                                                                                                    
    Se asume un automata celular de frontera 'fria' (o abierta, es                                                                  
    decir rodeada de 0's).                                                                                                          
    """
    try:
        val = grid[y][x]
        vec = [[0 for j in range(0,3)] for i in range(0,3)]
        for i in range(-1,2):
            for j in range(-1,2):
                # si la casilla vecina esta dentro de la rejilla, la                                                                
                # toma. Si no, asume un 0                                                                                           
                vec[i+1][j+1] = grid[y+i][x+j] if (y+i,x+j) >= (0,0) and y+i < len(grid) and x+j < len(grid[y+i]) else 0
    except Exception as e:
        return None
    return vec

def lifegame(grid):
    """                                                                                                                             
    Juego de la vida.                                                                                                               
                                                                                                                                    
    Toma por cada casilla su vecindad de VonNeumann y evalua la                                                                     
    cantidad de vecinos vivos de ella.                                                                                              
                                                                                                                                    
    -Si esta viva y tiene 2 o 3 vecinos vivos, queda viva                                                                           
    -De lo contrario muere                                                                                                          
    -Si esta muerta y tiene exactamente 3 vecinos vivos, vive                                                                       
    """
    # arreglo de 0's sobre el que se calculara siguiente iteracion                                                                  
    temp = [[0 for j in range(len(glider[i]))] for i in range(len(glider))]

    # recorre cada casilla de la rejilla y toma su vecindad, aplicando                                                              
    # despues reglas del juego                                                                                                      
    for i in range(len(glider)):
        for j in range(len(glider[i])):
            centro = glider[i][j]
            vec = vecindad((i,j), glider)
            if vec == None:
                return None

            # cuenta cantidad de vecinos vivos de la casilla                                                                        
            vecinos_vivos = 0
            for vi in range(len(vec)):
                for vj in range(len(vec)):
                    if (vi,vj) != (1,1) and vec[vi][vj] == 1:
                        vecinos_vivos += 1

            # aplica reglas del juego de la vida                                                                                    
            if centro == 1:
                if vecinos_vivos == 2 or vecinos_vivos == 3:
                    temp[i][j] = 1
                else:
                    temp[i][j] = 0
            else:
                if vecinos_vivos == 3:
                    temp[i][j] = 1
    return temp

#### MAIN ####                                                                                                                      
printg(glider)
for c in range(10):
    glider = lifegame(glider)
    if glider == None:
        print "Error!!!"
        break
    print ""
    printg(glider)

--- Eru kaluva tielyanna (Dios iluminará tu camino) "Ama y haz lo que quieras. Si callas, callarás con amor; si gritas, gritarás con amor; si corriges, corregirás con amor; si perdonas, perdonarás con amor. Si tienes el amor arraigado en ti, ninguna otra cosa sino amor serán tus frutos." (San Agustín) Solamente asegúrate que en realidad sea AMOR...