# Game of Life With Python

# Game of Life With Python

### Love coding and Python and have a god complex? Well, even if you don't meet that second criterion, you'll probably still enjoy this post on using data patterns in Python.

Join the DZone community and get the full member experience.

Join For FreeHortonworks Sandbox for HDP and HDF is your chance to get started on learning, developing, testing and trying out new features. Each download comes preconfigured with interactive tutorials, sample data and developments from the Apache community.

The game of life consists of a grid of cells where each cell can be dead or alive and the state of the cells can change at each time step. The state of a cell at the time step depends on the state of the grid at time *t-1* and it is determined with a very simple rule:

*A cell is alive if it's already alive and has two living neighbors, or if it has three live neighbors*.

We call the grid *universe* and the alive cells *population*. At each time step, the population evolves and we have a new *generation*. The evolution of the population is a fascinating process to observe because it can generate an incredible variety of patterns (and also puzzles!).

Implementing the game of life in Python is quite straightforward:

```
import numpy as np
def life(X, steps):
"""
Conway's Game of Life.
- X, matrix with the initial state of the game.
- steps, number of generations.
"""
def roll_it(x, y):
# rolls the matrix X in a given direction
# x=1, y=0 on the left; x=-1, y=0 right;
# x=0, y=1 top; x=0, y=-1 down; x=1, y=1 top left; ...
return np.roll(np.roll(X, y, axis=0), x, axis=1)
for _ in range(steps):
# count the number of neighbours
# the universe is considered toroidal
Y = roll_it(1, 0) + roll_it(0, 1) + roll_it(-1, 0) \
+ roll_it(0, -1) + roll_it(1, 1) + roll_it(-1, -1) \
+ roll_it(1, -1) + roll_it(-1, 1)
# game of life rules
X = np.logical_or(np.logical_and(X, Y ==2), Y==3)
X = X.astype(int)
yield X
```

The function *life* takes in input a matrix *X* which represents the universe of the game where each cell is alive if its corresponding element has value 1 and dead if 0. The function returns the next *steps* generations. At each time step, the number of neighbors of each cell is counted and the rule of the game is applied. Now we can create a universe with an initial state:

```
X = np.zeros((40, 40)) # 40 by 40 dead cells
# R-pentomino
X[23, 22:24] = 1
X[24, 21:23] = 1
X[25, 22] = 1
```

This initial state is known as the R-pentomino. It consists of five living cells organized as shown here (image from Wikipedia):

It is by far the most active polyomino with fewer than six cells, all of the others stabilize in at most 10 generations. Let's create a video to visualize the evolution of the system:

```
from matplotlib import pyplot as plt
import matplotlib.animation as manimation
FFMpegWriter = manimation.writers['ffmpeg']
metadata = dict(title='Game of life', artist='JustGlowing')
writer = FFMpegWriter(fps=10, metadata=metadata)
fig = plt.figure()
fig.patch.set_facecolor('black')
with writer.saving(fig, "game_of_life.mp4", 200):
plt.spy(X)
plt.axis('off')
writer.grab_frame()
plt.clf()
for x in life(X, 800):
plt.spy(x)
plt.axis('off')
writer.grab_frame()
plt.clf()
```

The result is as follows:

In the video, we can notice few very well known patterns like gliders and blinkers. Also, an exploding start at 0:55!

Hortonworks Community Connection (HCC) is an online collaboration destination for developers, DevOps, customers and partners to get answers to questions, collaborate on technical articles and share code examples from GitHub. Join the discussion.

Published at DZone with permission of Giuseppe Vettigli , DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

## {{ parent.title || parent.header.title}}

## {{ parent.tldr }}

## {{ parent.linkDescription }}

{{ parent.urlSource.name }}